Vulkan-Hpp: vulkan/vulkan_handles.hpp Source File

 // Copyright 2015-2024 The Khronos Group Inc.

 //

 // SPDX-License-Identifier: Apache-2.0 OR MIT

 //


 // This header is generated from the Khronos Vulkan XML API Registry.


 #ifndef VULKAN_HANDLES_HPP

 #define VULKAN_HANDLES_HPP


 namespace VULKAN_HPP_NAMESPACE

 {


   //===================================

   //=== STRUCT forward declarations ===

   //===================================


   //=== VK_VERSION_1_0 ===

   struct Extent2D;

   struct Extent3D;

   struct Offset2D;

   struct Offset3D;

   struct Rect2D;

   struct BaseInStructure;

   struct BaseOutStructure;

   struct BufferMemoryBarrier;

   struct DispatchIndirectCommand;

   struct DrawIndexedIndirectCommand;

   struct DrawIndirectCommand;

   struct ImageMemoryBarrier;

   struct MemoryBarrier;

   struct PipelineCacheHeaderVersionOne;

   struct AllocationCallbacks;

   struct ApplicationInfo;

   struct FormatProperties;

   struct ImageFormatProperties;

   struct InstanceCreateInfo;

   struct MemoryHeap;

   struct MemoryType;

   struct PhysicalDeviceFeatures;

   struct PhysicalDeviceLimits;

   struct PhysicalDeviceMemoryProperties;

   struct PhysicalDeviceProperties;

   struct PhysicalDeviceSparseProperties;

   struct QueueFamilyProperties;

   struct DeviceCreateInfo;

   struct DeviceQueueCreateInfo;

   struct ExtensionProperties;

   struct LayerProperties;

   struct SubmitInfo;

   struct MappedMemoryRange;

   struct MemoryAllocateInfo;

   struct MemoryRequirements;

   struct BindSparseInfo;

   struct ImageSubresource;

   struct SparseBufferMemoryBindInfo;

   struct SparseImageFormatProperties;

   struct SparseImageMemoryBind;

   struct SparseImageMemoryBindInfo;

   struct SparseImageMemoryRequirements;

   struct SparseImageOpaqueMemoryBindInfo;

   struct SparseMemoryBind;

   struct FenceCreateInfo;

   struct SemaphoreCreateInfo;

   struct EventCreateInfo;

   struct QueryPoolCreateInfo;

   struct BufferCreateInfo;

   struct BufferViewCreateInfo;

   struct ImageCreateInfo;

   struct SubresourceLayout;

   struct ComponentMapping;

   struct ImageSubresourceRange;

   struct ImageViewCreateInfo;

   struct ShaderModuleCreateInfo;

   struct PipelineCacheCreateInfo;

   struct ComputePipelineCreateInfo;

   struct GraphicsPipelineCreateInfo;

   struct PipelineColorBlendAttachmentState;

   struct PipelineColorBlendStateCreateInfo;

   struct PipelineDepthStencilStateCreateInfo;

   struct PipelineDynamicStateCreateInfo;

   struct PipelineInputAssemblyStateCreateInfo;

   struct PipelineMultisampleStateCreateInfo;

   struct PipelineRasterizationStateCreateInfo;

   struct PipelineShaderStageCreateInfo;

   struct PipelineTessellationStateCreateInfo;

   struct PipelineVertexInputStateCreateInfo;

   struct PipelineViewportStateCreateInfo;

   struct SpecializationInfo;

   struct SpecializationMapEntry;

   struct StencilOpState;

   struct VertexInputAttributeDescription;

   struct VertexInputBindingDescription;

   struct Viewport;

   struct PipelineLayoutCreateInfo;

   struct PushConstantRange;

   struct SamplerCreateInfo;

   struct CopyDescriptorSet;

   struct DescriptorBufferInfo;

   struct DescriptorImageInfo;

   struct DescriptorPoolCreateInfo;

   struct DescriptorPoolSize;

   struct DescriptorSetAllocateInfo;

   struct DescriptorSetLayoutBinding;

   struct DescriptorSetLayoutCreateInfo;

   struct WriteDescriptorSet;

   struct AttachmentDescription;

   struct AttachmentReference;

   struct FramebufferCreateInfo;

   struct RenderPassCreateInfo;

   struct SubpassDependency;

   struct SubpassDescription;

   struct CommandPoolCreateInfo;

   struct CommandBufferAllocateInfo;

   struct CommandBufferBeginInfo;

   struct CommandBufferInheritanceInfo;

   struct BufferCopy;

   struct BufferImageCopy;

   struct ClearAttachment;

   union ClearColorValue;

   struct ClearDepthStencilValue;

   struct ClearRect;

   union ClearValue;

   struct ImageBlit;

   struct ImageCopy;

   struct ImageResolve;

   struct ImageSubresourceLayers;

   struct RenderPassBeginInfo;


   //=== VK_VERSION_1_1 ===

   struct PhysicalDeviceSubgroupProperties;

   struct BindBufferMemoryInfo;

   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;

   struct BindImageMemoryInfo;

   using BindImageMemoryInfoKHR = BindImageMemoryInfo;

   struct PhysicalDevice16BitStorageFeatures;

   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;

   struct MemoryDedicatedRequirements;

   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;

   struct MemoryDedicatedAllocateInfo;

   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;

   struct MemoryAllocateFlagsInfo;

   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;

   struct DeviceGroupRenderPassBeginInfo;

   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;

   struct DeviceGroupCommandBufferBeginInfo;

   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;

   struct DeviceGroupSubmitInfo;

   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;

   struct DeviceGroupBindSparseInfo;

   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;

   struct BindBufferMemoryDeviceGroupInfo;

   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;

   struct BindImageMemoryDeviceGroupInfo;

   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;

   struct PhysicalDeviceGroupProperties;

   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;

   struct DeviceGroupDeviceCreateInfo;

   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;

   struct BufferMemoryRequirementsInfo2;

   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;

   struct ImageMemoryRequirementsInfo2;

   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;

   struct ImageSparseMemoryRequirementsInfo2;

   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;

   struct MemoryRequirements2;

   using MemoryRequirements2KHR = MemoryRequirements2;

   struct SparseImageMemoryRequirements2;

   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;

   struct PhysicalDeviceFeatures2;

   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;

   struct PhysicalDeviceProperties2;

   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;

   struct FormatProperties2;

   using FormatProperties2KHR = FormatProperties2;

   struct ImageFormatProperties2;

   using ImageFormatProperties2KHR = ImageFormatProperties2;

   struct PhysicalDeviceImageFormatInfo2;

   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;

   struct QueueFamilyProperties2;

   using QueueFamilyProperties2KHR = QueueFamilyProperties2;

   struct PhysicalDeviceMemoryProperties2;

   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;

   struct SparseImageFormatProperties2;

   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;

   struct PhysicalDeviceSparseImageFormatInfo2;

   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;

   struct PhysicalDevicePointClippingProperties;

   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;

   struct RenderPassInputAttachmentAspectCreateInfo;

   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;

   struct InputAttachmentAspectReference;

   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;

   struct ImageViewUsageCreateInfo;

   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;

   struct PipelineTessellationDomainOriginStateCreateInfo;

   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;

   struct RenderPassMultiviewCreateInfo;

   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;

   struct PhysicalDeviceMultiviewFeatures;

   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;

   struct PhysicalDeviceMultiviewProperties;

   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;

   struct PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;

   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;

   struct PhysicalDeviceProtectedMemoryFeatures;

   struct PhysicalDeviceProtectedMemoryProperties;

   struct DeviceQueueInfo2;

   struct ProtectedSubmitInfo;

   struct SamplerYcbcrConversionCreateInfo;

   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;

   struct SamplerYcbcrConversionInfo;

   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;

   struct BindImagePlaneMemoryInfo;

   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;

   struct ImagePlaneMemoryRequirementsInfo;

   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;

   struct PhysicalDeviceSamplerYcbcrConversionFeatures;

   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;

   struct SamplerYcbcrConversionImageFormatProperties;

   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;

   struct DescriptorUpdateTemplateEntry;

   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;

   struct DescriptorUpdateTemplateCreateInfo;

   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;

   struct ExternalMemoryProperties;

   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;

   struct PhysicalDeviceExternalImageFormatInfo;

   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;

   struct ExternalImageFormatProperties;

   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;

   struct PhysicalDeviceExternalBufferInfo;

   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;

   struct ExternalBufferProperties;

   using ExternalBufferPropertiesKHR = ExternalBufferProperties;

   struct PhysicalDeviceIDProperties;

   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;

   struct ExternalMemoryImageCreateInfo;

   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;

   struct ExternalMemoryBufferCreateInfo;

   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;

   struct ExportMemoryAllocateInfo;

   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;

   struct PhysicalDeviceExternalFenceInfo;

   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;

   struct ExternalFenceProperties;

   using ExternalFencePropertiesKHR = ExternalFenceProperties;

   struct ExportFenceCreateInfo;

   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;

   struct ExportSemaphoreCreateInfo;

   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;

   struct PhysicalDeviceExternalSemaphoreInfo;

   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;

   struct ExternalSemaphoreProperties;

   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;

   struct PhysicalDeviceMaintenance3Properties;

   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;

   struct DescriptorSetLayoutSupport;

   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;

   struct PhysicalDeviceShaderDrawParametersFeatures;

   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;


   //=== VK_VERSION_1_2 ===

   struct PhysicalDeviceVulkan11Features;

   struct PhysicalDeviceVulkan11Properties;

   struct PhysicalDeviceVulkan12Features;

   struct PhysicalDeviceVulkan12Properties;

   struct ImageFormatListCreateInfo;

   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;

   struct RenderPassCreateInfo2;

   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;

   struct AttachmentDescription2;

   using AttachmentDescription2KHR = AttachmentDescription2;

   struct AttachmentReference2;

   using AttachmentReference2KHR = AttachmentReference2;

   struct SubpassDescription2;

   using SubpassDescription2KHR = SubpassDescription2;

   struct SubpassDependency2;

   using SubpassDependency2KHR = SubpassDependency2;

   struct SubpassBeginInfo;

   using SubpassBeginInfoKHR = SubpassBeginInfo;

   struct SubpassEndInfo;

   using SubpassEndInfoKHR = SubpassEndInfo;

   struct PhysicalDevice8BitStorageFeatures;

   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;

   struct ConformanceVersion;

   using ConformanceVersionKHR = ConformanceVersion;

   struct PhysicalDeviceDriverProperties;

   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;

   struct PhysicalDeviceShaderAtomicInt64Features;

   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;

   struct PhysicalDeviceShaderFloat16Int8Features;

   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;

   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;

   struct PhysicalDeviceFloatControlsProperties;

   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;

   struct DescriptorSetLayoutBindingFlagsCreateInfo;

   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;

   struct PhysicalDeviceDescriptorIndexingFeatures;

   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;

   struct PhysicalDeviceDescriptorIndexingProperties;

   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;

   struct DescriptorSetVariableDescriptorCountAllocateInfo;

   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;

   struct DescriptorSetVariableDescriptorCountLayoutSupport;

   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;

   struct SubpassDescriptionDepthStencilResolve;

   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;

   struct PhysicalDeviceDepthStencilResolveProperties;

   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;

   struct PhysicalDeviceScalarBlockLayoutFeatures;

   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;

   struct ImageStencilUsageCreateInfo;

   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;

   struct SamplerReductionModeCreateInfo;

   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;

   struct PhysicalDeviceSamplerFilterMinmaxProperties;

   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;

   struct PhysicalDeviceVulkanMemoryModelFeatures;

   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;

   struct PhysicalDeviceImagelessFramebufferFeatures;

   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;

   struct FramebufferAttachmentsCreateInfo;

   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;

   struct FramebufferAttachmentImageInfo;

   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;

   struct RenderPassAttachmentBeginInfo;

   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;

   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;

   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;

   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

   struct AttachmentReferenceStencilLayout;

   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;

   struct AttachmentDescriptionStencilLayout;

   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;

   struct PhysicalDeviceHostQueryResetFeatures;

   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;

   struct PhysicalDeviceTimelineSemaphoreFeatures;

   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;

   struct PhysicalDeviceTimelineSemaphoreProperties;

   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;

   struct SemaphoreTypeCreateInfo;

   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;

   struct TimelineSemaphoreSubmitInfo;

   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;

   struct SemaphoreWaitInfo;

   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;

   struct SemaphoreSignalInfo;

   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;

   struct PhysicalDeviceBufferDeviceAddressFeatures;

   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;

   struct BufferDeviceAddressInfo;

   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;

   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;

   struct BufferOpaqueCaptureAddressCreateInfo;

   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;

   struct MemoryOpaqueCaptureAddressAllocateInfo;

   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;

   struct DeviceMemoryOpaqueCaptureAddressInfo;

   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;


   //=== VK_VERSION_1_3 ===

   struct PhysicalDeviceVulkan13Features;

   struct PhysicalDeviceVulkan13Properties;

   struct PipelineCreationFeedbackCreateInfo;

   using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;

   struct PipelineCreationFeedback;

   using PipelineCreationFeedbackEXT = PipelineCreationFeedback;

   struct PhysicalDeviceShaderTerminateInvocationFeatures;

   using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;

   struct PhysicalDeviceToolProperties;

   using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;

   struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

   using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

   struct PhysicalDevicePrivateDataFeatures;

   using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;

   struct DevicePrivateDataCreateInfo;

   using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;

   struct PrivateDataSlotCreateInfo;

   using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;

   struct PhysicalDevicePipelineCreationCacheControlFeatures;

   using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;

   struct MemoryBarrier2;

   using MemoryBarrier2KHR = MemoryBarrier2;

   struct BufferMemoryBarrier2;

   using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;

   struct ImageMemoryBarrier2;

   using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;

   struct DependencyInfo;

   using DependencyInfoKHR = DependencyInfo;

   struct SubmitInfo2;

   using SubmitInfo2KHR = SubmitInfo2;

   struct SemaphoreSubmitInfo;

   using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;

   struct CommandBufferSubmitInfo;

   using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;

   struct PhysicalDeviceSynchronization2Features;

   using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;

   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

   using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

   struct PhysicalDeviceImageRobustnessFeatures;

   using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;

   struct CopyBufferInfo2;

   using CopyBufferInfo2KHR = CopyBufferInfo2;

   struct CopyImageInfo2;

   using CopyImageInfo2KHR = CopyImageInfo2;

   struct CopyBufferToImageInfo2;

   using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;

   struct CopyImageToBufferInfo2;

   using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;

   struct BlitImageInfo2;

   using BlitImageInfo2KHR = BlitImageInfo2;

   struct ResolveImageInfo2;

   using ResolveImageInfo2KHR = ResolveImageInfo2;

   struct BufferCopy2;

   using BufferCopy2KHR = BufferCopy2;

   struct ImageCopy2;

   using ImageCopy2KHR = ImageCopy2;

   struct ImageBlit2;

   using ImageBlit2KHR = ImageBlit2;

   struct BufferImageCopy2;

   using BufferImageCopy2KHR = BufferImageCopy2;

   struct ImageResolve2;

   using ImageResolve2KHR = ImageResolve2;

   struct PhysicalDeviceSubgroupSizeControlFeatures;

   using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;

   struct PhysicalDeviceSubgroupSizeControlProperties;

   using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;

   struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;

   using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;

   using ShaderRequiredSubgroupSizeCreateInfoEXT              = PipelineShaderStageRequiredSubgroupSizeCreateInfo;

   struct PhysicalDeviceInlineUniformBlockFeatures;

   using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;

   struct PhysicalDeviceInlineUniformBlockProperties;

   using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;

   struct WriteDescriptorSetInlineUniformBlock;

   using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;

   struct DescriptorPoolInlineUniformBlockCreateInfo;

   using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;

   struct PhysicalDeviceTextureCompressionASTCHDRFeatures;

   using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;

   struct RenderingInfo;

   using RenderingInfoKHR = RenderingInfo;

   struct RenderingAttachmentInfo;

   using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;

   struct PipelineRenderingCreateInfo;

   using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;

   struct PhysicalDeviceDynamicRenderingFeatures;

   using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;

   struct CommandBufferInheritanceRenderingInfo;

   using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;

   struct PhysicalDeviceShaderIntegerDotProductFeatures;

   using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;

   struct PhysicalDeviceShaderIntegerDotProductProperties;

   using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;

   struct PhysicalDeviceTexelBufferAlignmentProperties;

   using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;

   struct FormatProperties3;

   using FormatProperties3KHR = FormatProperties3;

   struct PhysicalDeviceMaintenance4Features;

   using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;

   struct PhysicalDeviceMaintenance4Properties;

   using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;

   struct DeviceBufferMemoryRequirements;

   using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;

   struct DeviceImageMemoryRequirements;

   using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;


   //=== VK_KHR_surface ===

   struct SurfaceCapabilitiesKHR;

   struct SurfaceFormatKHR;


   //=== VK_KHR_swapchain ===

   struct SwapchainCreateInfoKHR;

   struct PresentInfoKHR;

   struct ImageSwapchainCreateInfoKHR;

   struct BindImageMemorySwapchainInfoKHR;

   struct AcquireNextImageInfoKHR;

   struct DeviceGroupPresentCapabilitiesKHR;

   struct DeviceGroupPresentInfoKHR;

   struct DeviceGroupSwapchainCreateInfoKHR;


   //=== VK_KHR_display ===

   struct DisplayModeCreateInfoKHR;

   struct DisplayModeParametersKHR;

   struct DisplayModePropertiesKHR;

   struct DisplayPlaneCapabilitiesKHR;

   struct DisplayPlanePropertiesKHR;

   struct DisplayPropertiesKHR;

   struct DisplaySurfaceCreateInfoKHR;


   //=== VK_KHR_display_swapchain ===

   struct DisplayPresentInfoKHR;


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

   //=== VK_KHR_xlib_surface ===

   struct XlibSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

   //=== VK_KHR_xcb_surface ===

   struct XcbSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

   //=== VK_KHR_wayland_surface ===

   struct WaylandSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

   //=== VK_KHR_android_surface ===

   struct AndroidSurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_win32_surface ===

   struct Win32SurfaceCreateInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_debug_report ===

   struct DebugReportCallbackCreateInfoEXT;


   //=== VK_AMD_rasterization_order ===

   struct PipelineRasterizationStateRasterizationOrderAMD;


   //=== VK_EXT_debug_marker ===

   struct DebugMarkerObjectNameInfoEXT;

   struct DebugMarkerObjectTagInfoEXT;

   struct DebugMarkerMarkerInfoEXT;


   //=== VK_KHR_video_queue ===

   struct QueueFamilyQueryResultStatusPropertiesKHR;

   struct QueueFamilyVideoPropertiesKHR;

   struct VideoProfileInfoKHR;

   struct VideoProfileListInfoKHR;

   struct VideoCapabilitiesKHR;

   struct PhysicalDeviceVideoFormatInfoKHR;

   struct VideoFormatPropertiesKHR;

   struct VideoPictureResourceInfoKHR;

   struct VideoReferenceSlotInfoKHR;

   struct VideoSessionMemoryRequirementsKHR;

   struct BindVideoSessionMemoryInfoKHR;

   struct VideoSessionCreateInfoKHR;

   struct VideoSessionParametersCreateInfoKHR;

   struct VideoSessionParametersUpdateInfoKHR;

   struct VideoBeginCodingInfoKHR;

   struct VideoEndCodingInfoKHR;

   struct VideoCodingControlInfoKHR;


   //=== VK_KHR_video_decode_queue ===

   struct VideoDecodeCapabilitiesKHR;

   struct VideoDecodeUsageInfoKHR;

   struct VideoDecodeInfoKHR;


   //=== VK_NV_dedicated_allocation ===

   struct DedicatedAllocationImageCreateInfoNV;

   struct DedicatedAllocationBufferCreateInfoNV;

   struct DedicatedAllocationMemoryAllocateInfoNV;


   //=== VK_EXT_transform_feedback ===

   struct PhysicalDeviceTransformFeedbackFeaturesEXT;

   struct PhysicalDeviceTransformFeedbackPropertiesEXT;

   struct PipelineRasterizationStateStreamCreateInfoEXT;


   //=== VK_NVX_binary_import ===

   struct CuModuleCreateInfoNVX;

   struct CuFunctionCreateInfoNVX;

   struct CuLaunchInfoNVX;


   //=== VK_NVX_image_view_handle ===

   struct ImageViewHandleInfoNVX;

   struct ImageViewAddressPropertiesNVX;


   //=== VK_KHR_video_encode_h264 ===

   struct VideoEncodeH264CapabilitiesKHR;

   struct VideoEncodeH264QualityLevelPropertiesKHR;

   struct VideoEncodeH264SessionCreateInfoKHR;

   struct VideoEncodeH264SessionParametersCreateInfoKHR;

   struct VideoEncodeH264SessionParametersAddInfoKHR;

   struct VideoEncodeH264SessionParametersGetInfoKHR;

   struct VideoEncodeH264SessionParametersFeedbackInfoKHR;

   struct VideoEncodeH264PictureInfoKHR;

   struct VideoEncodeH264DpbSlotInfoKHR;

   struct VideoEncodeH264NaluSliceInfoKHR;

   struct VideoEncodeH264ProfileInfoKHR;

   struct VideoEncodeH264RateControlInfoKHR;

   struct VideoEncodeH264RateControlLayerInfoKHR;

   struct VideoEncodeH264QpKHR;

   struct VideoEncodeH264FrameSizeKHR;

   struct VideoEncodeH264GopRemainingFrameInfoKHR;


   //=== VK_KHR_video_encode_h265 ===

   struct VideoEncodeH265CapabilitiesKHR;

   struct VideoEncodeH265SessionCreateInfoKHR;

   struct VideoEncodeH265QualityLevelPropertiesKHR;

   struct VideoEncodeH265SessionParametersCreateInfoKHR;

   struct VideoEncodeH265SessionParametersAddInfoKHR;

   struct VideoEncodeH265SessionParametersGetInfoKHR;

   struct VideoEncodeH265SessionParametersFeedbackInfoKHR;

   struct VideoEncodeH265PictureInfoKHR;

   struct VideoEncodeH265DpbSlotInfoKHR;

   struct VideoEncodeH265NaluSliceSegmentInfoKHR;

   struct VideoEncodeH265ProfileInfoKHR;

   struct VideoEncodeH265RateControlInfoKHR;

   struct VideoEncodeH265RateControlLayerInfoKHR;

   struct VideoEncodeH265QpKHR;

   struct VideoEncodeH265FrameSizeKHR;

   struct VideoEncodeH265GopRemainingFrameInfoKHR;


   //=== VK_KHR_video_decode_h264 ===

   struct VideoDecodeH264ProfileInfoKHR;

   struct VideoDecodeH264CapabilitiesKHR;

   struct VideoDecodeH264SessionParametersCreateInfoKHR;

   struct VideoDecodeH264SessionParametersAddInfoKHR;

   struct VideoDecodeH264PictureInfoKHR;

   struct VideoDecodeH264DpbSlotInfoKHR;


   //=== VK_AMD_texture_gather_bias_lod ===

   struct TextureLODGatherFormatPropertiesAMD;


   //=== VK_AMD_shader_info ===

   struct ShaderResourceUsageAMD;

   struct ShaderStatisticsInfoAMD;


   //=== VK_KHR_dynamic_rendering ===

   struct RenderingFragmentShadingRateAttachmentInfoKHR;

   struct RenderingFragmentDensityMapAttachmentInfoEXT;

   struct AttachmentSampleCountInfoAMD;

   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;

   struct MultiviewPerViewAttributesInfoNVX;


 #if defined( VK_USE_PLATFORM_GGP )

   //=== VK_GGP_stream_descriptor_surface ===

   struct StreamDescriptorSurfaceCreateInfoGGP;

 #endif /*VK_USE_PLATFORM_GGP*/


   //=== VK_NV_corner_sampled_image ===

   struct PhysicalDeviceCornerSampledImageFeaturesNV;


   //=== VK_NV_external_memory_capabilities ===

   struct ExternalImageFormatPropertiesNV;


   //=== VK_NV_external_memory ===

   struct ExternalMemoryImageCreateInfoNV;

   struct ExportMemoryAllocateInfoNV;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_NV_external_memory_win32 ===

   struct ImportMemoryWin32HandleInfoNV;

   struct ExportMemoryWin32HandleInfoNV;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_NV_win32_keyed_mutex ===

   struct Win32KeyedMutexAcquireReleaseInfoNV;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_validation_flags ===

   struct ValidationFlagsEXT;


 #if defined( VK_USE_PLATFORM_VI_NN )

   //=== VK_NN_vi_surface ===

   struct ViSurfaceCreateInfoNN;

 #endif /*VK_USE_PLATFORM_VI_NN*/


   //=== VK_EXT_astc_decode_mode ===

   struct ImageViewASTCDecodeModeEXT;

   struct PhysicalDeviceASTCDecodeFeaturesEXT;


   //=== VK_EXT_pipeline_robustness ===

   struct PhysicalDevicePipelineRobustnessFeaturesEXT;

   struct PhysicalDevicePipelineRobustnessPropertiesEXT;

   struct PipelineRobustnessCreateInfoEXT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_memory_win32 ===

   struct ImportMemoryWin32HandleInfoKHR;

   struct ExportMemoryWin32HandleInfoKHR;

   struct MemoryWin32HandlePropertiesKHR;

   struct MemoryGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_memory_fd ===

   struct ImportMemoryFdInfoKHR;

   struct MemoryFdPropertiesKHR;

   struct MemoryGetFdInfoKHR;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_win32_keyed_mutex ===

   struct Win32KeyedMutexAcquireReleaseInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_semaphore_win32 ===

   struct ImportSemaphoreWin32HandleInfoKHR;

   struct ExportSemaphoreWin32HandleInfoKHR;

   struct D3D12FenceSubmitInfoKHR;

   struct SemaphoreGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_semaphore_fd ===

   struct ImportSemaphoreFdInfoKHR;

   struct SemaphoreGetFdInfoKHR;


   //=== VK_KHR_push_descriptor ===

   struct PhysicalDevicePushDescriptorPropertiesKHR;


   //=== VK_EXT_conditional_rendering ===

   struct ConditionalRenderingBeginInfoEXT;

   struct PhysicalDeviceConditionalRenderingFeaturesEXT;

   struct CommandBufferInheritanceConditionalRenderingInfoEXT;


   //=== VK_KHR_incremental_present ===

   struct PresentRegionsKHR;

   struct PresentRegionKHR;

   struct RectLayerKHR;


   //=== VK_NV_clip_space_w_scaling ===

   struct ViewportWScalingNV;

   struct PipelineViewportWScalingStateCreateInfoNV;


   //=== VK_EXT_display_surface_counter ===

   struct SurfaceCapabilities2EXT;


   //=== VK_EXT_display_control ===

   struct DisplayPowerInfoEXT;

   struct DeviceEventInfoEXT;

   struct DisplayEventInfoEXT;

   struct SwapchainCounterCreateInfoEXT;


   //=== VK_GOOGLE_display_timing ===

   struct RefreshCycleDurationGOOGLE;

   struct PastPresentationTimingGOOGLE;

   struct PresentTimesInfoGOOGLE;

   struct PresentTimeGOOGLE;


   //=== VK_NVX_multiview_per_view_attributes ===

   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;


   //=== VK_NV_viewport_swizzle ===

   struct ViewportSwizzleNV;

   struct PipelineViewportSwizzleStateCreateInfoNV;


   //=== VK_EXT_discard_rectangles ===

   struct PhysicalDeviceDiscardRectanglePropertiesEXT;

   struct PipelineDiscardRectangleStateCreateInfoEXT;


   //=== VK_EXT_conservative_rasterization ===

   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;

   struct PipelineRasterizationConservativeStateCreateInfoEXT;


   //=== VK_EXT_depth_clip_enable ===

   struct PhysicalDeviceDepthClipEnableFeaturesEXT;

   struct PipelineRasterizationDepthClipStateCreateInfoEXT;


   //=== VK_EXT_hdr_metadata ===

   struct HdrMetadataEXT;

   struct XYColorEXT;


   //=== VK_IMG_relaxed_line_rasterization ===

   struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;


   //=== VK_KHR_shared_presentable_image ===

   struct SharedPresentSurfaceCapabilitiesKHR;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_KHR_external_fence_win32 ===

   struct ImportFenceWin32HandleInfoKHR;

   struct ExportFenceWin32HandleInfoKHR;

   struct FenceGetWin32HandleInfoKHR;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_KHR_external_fence_fd ===

   struct ImportFenceFdInfoKHR;

   struct FenceGetFdInfoKHR;


   //=== VK_KHR_performance_query ===

   struct PhysicalDevicePerformanceQueryFeaturesKHR;

   struct PhysicalDevicePerformanceQueryPropertiesKHR;

   struct PerformanceCounterKHR;

   struct PerformanceCounterDescriptionKHR;

   struct QueryPoolPerformanceCreateInfoKHR;

   union PerformanceCounterResultKHR;

   struct AcquireProfilingLockInfoKHR;

   struct PerformanceQuerySubmitInfoKHR;


   //=== VK_KHR_get_surface_capabilities2 ===

   struct PhysicalDeviceSurfaceInfo2KHR;

   struct SurfaceCapabilities2KHR;

   struct SurfaceFormat2KHR;


   //=== VK_KHR_get_display_properties2 ===

   struct DisplayProperties2KHR;

   struct DisplayPlaneProperties2KHR;

   struct DisplayModeProperties2KHR;

   struct DisplayPlaneInfo2KHR;

   struct DisplayPlaneCapabilities2KHR;


 #if defined( VK_USE_PLATFORM_IOS_MVK )

   //=== VK_MVK_ios_surface ===

   struct IOSSurfaceCreateInfoMVK;

 #endif /*VK_USE_PLATFORM_IOS_MVK*/


 #if defined( VK_USE_PLATFORM_MACOS_MVK )

   //=== VK_MVK_macos_surface ===

   struct MacOSSurfaceCreateInfoMVK;

 #endif /*VK_USE_PLATFORM_MACOS_MVK*/


   //=== VK_EXT_debug_utils ===

   struct DebugUtilsLabelEXT;

   struct DebugUtilsMessengerCallbackDataEXT;

   struct DebugUtilsMessengerCreateInfoEXT;

   struct DebugUtilsObjectNameInfoEXT;

   struct DebugUtilsObjectTagInfoEXT;


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

   //=== VK_ANDROID_external_memory_android_hardware_buffer ===

   struct AndroidHardwareBufferUsageANDROID;

   struct AndroidHardwareBufferPropertiesANDROID;

   struct AndroidHardwareBufferFormatPropertiesANDROID;

   struct ImportAndroidHardwareBufferInfoANDROID;

   struct MemoryGetAndroidHardwareBufferInfoANDROID;

   struct ExternalFormatANDROID;

   struct AndroidHardwareBufferFormatProperties2ANDROID;

 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_AMDX_shader_enqueue ===

   struct PhysicalDeviceShaderEnqueueFeaturesAMDX;

   struct PhysicalDeviceShaderEnqueuePropertiesAMDX;

   struct ExecutionGraphPipelineScratchSizeAMDX;

   struct ExecutionGraphPipelineCreateInfoAMDX;

   struct DispatchGraphInfoAMDX;

   struct DispatchGraphCountInfoAMDX;

   struct PipelineShaderStageNodeCreateInfoAMDX;

   union DeviceOrHostAddressConstAMDX;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_EXT_sample_locations ===

   struct SampleLocationEXT;

   struct SampleLocationsInfoEXT;

   struct AttachmentSampleLocationsEXT;

   struct SubpassSampleLocationsEXT;

   struct RenderPassSampleLocationsBeginInfoEXT;

   struct PipelineSampleLocationsStateCreateInfoEXT;

   struct PhysicalDeviceSampleLocationsPropertiesEXT;

   struct MultisamplePropertiesEXT;


   //=== VK_EXT_blend_operation_advanced ===

   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;

   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;

   struct PipelineColorBlendAdvancedStateCreateInfoEXT;


   //=== VK_NV_fragment_coverage_to_color ===

   struct PipelineCoverageToColorStateCreateInfoNV;


   //=== VK_KHR_acceleration_structure ===

   union DeviceOrHostAddressKHR;

   union DeviceOrHostAddressConstKHR;

   struct AccelerationStructureBuildRangeInfoKHR;

   struct AabbPositionsKHR;

   using AabbPositionsNV = AabbPositionsKHR;

   struct AccelerationStructureGeometryTrianglesDataKHR;

   struct TransformMatrixKHR;

   using TransformMatrixNV = TransformMatrixKHR;

   struct AccelerationStructureBuildGeometryInfoKHR;

   struct AccelerationStructureGeometryAabbsDataKHR;

   struct AccelerationStructureInstanceKHR;

   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;

   struct AccelerationStructureGeometryInstancesDataKHR;

   union AccelerationStructureGeometryDataKHR;

   struct AccelerationStructureGeometryKHR;

   struct AccelerationStructureCreateInfoKHR;

   struct WriteDescriptorSetAccelerationStructureKHR;

   struct PhysicalDeviceAccelerationStructureFeaturesKHR;

   struct PhysicalDeviceAccelerationStructurePropertiesKHR;

   struct AccelerationStructureDeviceAddressInfoKHR;

   struct AccelerationStructureVersionInfoKHR;

   struct CopyAccelerationStructureToMemoryInfoKHR;

   struct CopyMemoryToAccelerationStructureInfoKHR;

   struct CopyAccelerationStructureInfoKHR;

   struct AccelerationStructureBuildSizesInfoKHR;


   //=== VK_KHR_ray_tracing_pipeline ===

   struct RayTracingShaderGroupCreateInfoKHR;

   struct RayTracingPipelineCreateInfoKHR;

   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;

   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;

   struct StridedDeviceAddressRegionKHR;

   struct TraceRaysIndirectCommandKHR;

   struct RayTracingPipelineInterfaceCreateInfoKHR;


   //=== VK_KHR_ray_query ===

   struct PhysicalDeviceRayQueryFeaturesKHR;


   //=== VK_NV_framebuffer_mixed_samples ===

   struct PipelineCoverageModulationStateCreateInfoNV;


   //=== VK_NV_shader_sm_builtins ===

   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;

   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;


   //=== VK_EXT_image_drm_format_modifier ===

   struct DrmFormatModifierPropertiesListEXT;

   struct DrmFormatModifierPropertiesEXT;

   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;

   struct ImageDrmFormatModifierListCreateInfoEXT;

   struct ImageDrmFormatModifierExplicitCreateInfoEXT;

   struct ImageDrmFormatModifierPropertiesEXT;

   struct DrmFormatModifierPropertiesList2EXT;

   struct DrmFormatModifierProperties2EXT;


   //=== VK_EXT_validation_cache ===

   struct ValidationCacheCreateInfoEXT;

   struct ShaderModuleValidationCacheCreateInfoEXT;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_KHR_portability_subset ===

   struct PhysicalDevicePortabilitySubsetFeaturesKHR;

   struct PhysicalDevicePortabilitySubsetPropertiesKHR;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_NV_shading_rate_image ===

   struct ShadingRatePaletteNV;

   struct PipelineViewportShadingRateImageStateCreateInfoNV;

   struct PhysicalDeviceShadingRateImageFeaturesNV;

   struct PhysicalDeviceShadingRateImagePropertiesNV;

   struct CoarseSampleLocationNV;

   struct CoarseSampleOrderCustomNV;

   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;


   //=== VK_NV_ray_tracing ===

   struct RayTracingShaderGroupCreateInfoNV;

   struct RayTracingPipelineCreateInfoNV;

   struct GeometryTrianglesNV;

   struct GeometryAABBNV;

   struct GeometryDataNV;

   struct GeometryNV;

   struct AccelerationStructureInfoNV;

   struct AccelerationStructureCreateInfoNV;

   struct BindAccelerationStructureMemoryInfoNV;

   struct WriteDescriptorSetAccelerationStructureNV;

   struct AccelerationStructureMemoryRequirementsInfoNV;

   struct PhysicalDeviceRayTracingPropertiesNV;


   //=== VK_NV_representative_fragment_test ===

   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;

   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;


   //=== VK_EXT_filter_cubic ===

   struct PhysicalDeviceImageViewImageFormatInfoEXT;

   struct FilterCubicImageViewImageFormatPropertiesEXT;


   //=== VK_EXT_external_memory_host ===

   struct ImportMemoryHostPointerInfoEXT;

   struct MemoryHostPointerPropertiesEXT;

   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;


   //=== VK_KHR_shader_clock ===

   struct PhysicalDeviceShaderClockFeaturesKHR;


   //=== VK_AMD_pipeline_compiler_control ===

   struct PipelineCompilerControlCreateInfoAMD;


   //=== VK_AMD_shader_core_properties ===

   struct PhysicalDeviceShaderCorePropertiesAMD;


   //=== VK_KHR_video_decode_h265 ===

   struct VideoDecodeH265ProfileInfoKHR;

   struct VideoDecodeH265CapabilitiesKHR;

   struct VideoDecodeH265SessionParametersCreateInfoKHR;

   struct VideoDecodeH265SessionParametersAddInfoKHR;

   struct VideoDecodeH265PictureInfoKHR;

   struct VideoDecodeH265DpbSlotInfoKHR;


   //=== VK_KHR_global_priority ===

   struct DeviceQueueGlobalPriorityCreateInfoKHR;

   using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;

   struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;

   using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;

   struct QueueFamilyGlobalPriorityPropertiesKHR;

   using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;


   //=== VK_AMD_memory_overallocation_behavior ===

   struct DeviceMemoryOverallocationCreateInfoAMD;


   //=== VK_EXT_vertex_attribute_divisor ===

   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;


 #if defined( VK_USE_PLATFORM_GGP )

   //=== VK_GGP_frame_token ===

   struct PresentFrameTokenGGP;

 #endif /*VK_USE_PLATFORM_GGP*/


   //=== VK_NV_compute_shader_derivatives ===

   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;


   //=== VK_NV_mesh_shader ===

   struct PhysicalDeviceMeshShaderFeaturesNV;

   struct PhysicalDeviceMeshShaderPropertiesNV;

   struct DrawMeshTasksIndirectCommandNV;


   //=== VK_NV_shader_image_footprint ===

   struct PhysicalDeviceShaderImageFootprintFeaturesNV;


   //=== VK_NV_scissor_exclusive ===

   struct PipelineViewportExclusiveScissorStateCreateInfoNV;

   struct PhysicalDeviceExclusiveScissorFeaturesNV;


   //=== VK_NV_device_diagnostic_checkpoints ===

   struct QueueFamilyCheckpointPropertiesNV;

   struct CheckpointDataNV;


   //=== VK_INTEL_shader_integer_functions2 ===

   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;


   //=== VK_INTEL_performance_query ===

   union PerformanceValueDataINTEL;

   struct PerformanceValueINTEL;

   struct InitializePerformanceApiInfoINTEL;

   struct QueryPoolPerformanceQueryCreateInfoINTEL;

   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;

   struct PerformanceMarkerInfoINTEL;

   struct PerformanceStreamMarkerInfoINTEL;

   struct PerformanceOverrideInfoINTEL;

   struct PerformanceConfigurationAcquireInfoINTEL;


   //=== VK_EXT_pci_bus_info ===

   struct PhysicalDevicePCIBusInfoPropertiesEXT;


   //=== VK_AMD_display_native_hdr ===

   struct DisplayNativeHdrSurfaceCapabilitiesAMD;

   struct SwapchainDisplayNativeHdrCreateInfoAMD;


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_imagepipe_surface ===

   struct ImagePipeSurfaceCreateInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_METAL_EXT )

   //=== VK_EXT_metal_surface ===

   struct MetalSurfaceCreateInfoEXT;

 #endif /*VK_USE_PLATFORM_METAL_EXT*/


   //=== VK_EXT_fragment_density_map ===

   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;

   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;

   struct RenderPassFragmentDensityMapCreateInfoEXT;


   //=== VK_KHR_fragment_shading_rate ===

   struct FragmentShadingRateAttachmentInfoKHR;

   struct PipelineFragmentShadingRateStateCreateInfoKHR;

   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;

   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;

   struct PhysicalDeviceFragmentShadingRateKHR;


   //=== VK_AMD_shader_core_properties2 ===

   struct PhysicalDeviceShaderCoreProperties2AMD;


   //=== VK_AMD_device_coherent_memory ===

   struct PhysicalDeviceCoherentMemoryFeaturesAMD;


   //=== VK_EXT_shader_image_atomic_int64 ===

   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;


   //=== VK_EXT_memory_budget ===

   struct PhysicalDeviceMemoryBudgetPropertiesEXT;


   //=== VK_EXT_memory_priority ===

   struct PhysicalDeviceMemoryPriorityFeaturesEXT;

   struct MemoryPriorityAllocateInfoEXT;


   //=== VK_KHR_surface_protected_capabilities ===

   struct SurfaceProtectedCapabilitiesKHR;


   //=== VK_NV_dedicated_allocation_image_aliasing ===

   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;


   //=== VK_EXT_buffer_device_address ===

   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;

   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;

   struct BufferDeviceAddressCreateInfoEXT;


   //=== VK_EXT_validation_features ===

   struct ValidationFeaturesEXT;


   //=== VK_KHR_present_wait ===

   struct PhysicalDevicePresentWaitFeaturesKHR;


   //=== VK_NV_cooperative_matrix ===

   struct CooperativeMatrixPropertiesNV;

   struct PhysicalDeviceCooperativeMatrixFeaturesNV;

   struct PhysicalDeviceCooperativeMatrixPropertiesNV;


   //=== VK_NV_coverage_reduction_mode ===

   struct PhysicalDeviceCoverageReductionModeFeaturesNV;

   struct PipelineCoverageReductionStateCreateInfoNV;

   struct FramebufferMixedSamplesCombinationNV;


   //=== VK_EXT_fragment_shader_interlock ===

   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;


   //=== VK_EXT_ycbcr_image_arrays ===

   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;


   //=== VK_EXT_provoking_vertex ===

   struct PhysicalDeviceProvokingVertexFeaturesEXT;

   struct PhysicalDeviceProvokingVertexPropertiesEXT;

   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

   //=== VK_EXT_full_screen_exclusive ===

   struct SurfaceFullScreenExclusiveInfoEXT;

   struct SurfaceCapabilitiesFullScreenExclusiveEXT;

   struct SurfaceFullScreenExclusiveWin32InfoEXT;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


   //=== VK_EXT_headless_surface ===

   struct HeadlessSurfaceCreateInfoEXT;


   //=== VK_EXT_line_rasterization ===

   struct PhysicalDeviceLineRasterizationFeaturesEXT;

   struct PhysicalDeviceLineRasterizationPropertiesEXT;

   struct PipelineRasterizationLineStateCreateInfoEXT;


   //=== VK_EXT_shader_atomic_float ===

   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;


   //=== VK_EXT_index_type_uint8 ===

   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;


   //=== VK_EXT_extended_dynamic_state ===

   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;


   //=== VK_KHR_pipeline_executable_properties ===

   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

   struct PipelineInfoKHR;

   using PipelineInfoEXT = PipelineInfoKHR;

   struct PipelineExecutablePropertiesKHR;

   struct PipelineExecutableInfoKHR;

   union PipelineExecutableStatisticValueKHR;

   struct PipelineExecutableStatisticKHR;

   struct PipelineExecutableInternalRepresentationKHR;


   //=== VK_EXT_host_image_copy ===

   struct PhysicalDeviceHostImageCopyFeaturesEXT;

   struct PhysicalDeviceHostImageCopyPropertiesEXT;

   struct MemoryToImageCopyEXT;

   struct ImageToMemoryCopyEXT;

   struct CopyMemoryToImageInfoEXT;

   struct CopyImageToMemoryInfoEXT;

   struct CopyImageToImageInfoEXT;

   struct HostImageLayoutTransitionInfoEXT;

   struct SubresourceHostMemcpySizeEXT;

   struct HostImageCopyDevicePerformanceQueryEXT;


   //=== VK_KHR_map_memory2 ===

   struct MemoryMapInfoKHR;

   struct MemoryUnmapInfoKHR;


   //=== VK_EXT_shader_atomic_float2 ===

   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;


   //=== VK_EXT_surface_maintenance1 ===

   struct SurfacePresentModeEXT;

   struct SurfacePresentScalingCapabilitiesEXT;

   struct SurfacePresentModeCompatibilityEXT;


   //=== VK_EXT_swapchain_maintenance1 ===

   struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;

   struct SwapchainPresentFenceInfoEXT;

   struct SwapchainPresentModesCreateInfoEXT;

   struct SwapchainPresentModeInfoEXT;

   struct SwapchainPresentScalingCreateInfoEXT;

   struct ReleaseSwapchainImagesInfoEXT;


   //=== VK_NV_device_generated_commands ===

   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;

   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

   struct GraphicsShaderGroupCreateInfoNV;

   struct GraphicsPipelineShaderGroupsCreateInfoNV;

   struct BindShaderGroupIndirectCommandNV;

   struct BindIndexBufferIndirectCommandNV;

   struct BindVertexBufferIndirectCommandNV;

   struct SetStateFlagsIndirectCommandNV;

   struct IndirectCommandsStreamNV;

   struct IndirectCommandsLayoutTokenNV;

   struct IndirectCommandsLayoutCreateInfoNV;

   struct GeneratedCommandsInfoNV;

   struct GeneratedCommandsMemoryRequirementsInfoNV;


   //=== VK_NV_inherited_viewport_scissor ===

   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;

   struct CommandBufferInheritanceViewportScissorInfoNV;


   //=== VK_EXT_texel_buffer_alignment ===

   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;


   //=== VK_QCOM_render_pass_transform ===

   struct RenderPassTransformBeginInfoQCOM;

   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;


   //=== VK_EXT_depth_bias_control ===

   struct PhysicalDeviceDepthBiasControlFeaturesEXT;

   struct DepthBiasInfoEXT;

   struct DepthBiasRepresentationInfoEXT;


   //=== VK_EXT_device_memory_report ===

   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;

   struct DeviceDeviceMemoryReportCreateInfoEXT;

   struct DeviceMemoryReportCallbackDataEXT;


   //=== VK_EXT_robustness2 ===

   struct PhysicalDeviceRobustness2FeaturesEXT;

   struct PhysicalDeviceRobustness2PropertiesEXT;


   //=== VK_EXT_custom_border_color ===

   struct SamplerCustomBorderColorCreateInfoEXT;

   struct PhysicalDeviceCustomBorderColorPropertiesEXT;

   struct PhysicalDeviceCustomBorderColorFeaturesEXT;


   //=== VK_KHR_pipeline_library ===

   struct PipelineLibraryCreateInfoKHR;


   //=== VK_NV_present_barrier ===

   struct PhysicalDevicePresentBarrierFeaturesNV;

   struct SurfaceCapabilitiesPresentBarrierNV;

   struct SwapchainPresentBarrierCreateInfoNV;


   //=== VK_KHR_present_id ===

   struct PresentIdKHR;

   struct PhysicalDevicePresentIdFeaturesKHR;


   //=== VK_KHR_video_encode_queue ===

   struct VideoEncodeInfoKHR;

   struct VideoEncodeCapabilitiesKHR;

   struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;

   struct VideoEncodeUsageInfoKHR;

   struct VideoEncodeRateControlInfoKHR;

   struct VideoEncodeRateControlLayerInfoKHR;

   struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;

   struct VideoEncodeQualityLevelPropertiesKHR;

   struct VideoEncodeQualityLevelInfoKHR;

   struct VideoEncodeSessionParametersGetInfoKHR;

   struct VideoEncodeSessionParametersFeedbackInfoKHR;


   //=== VK_NV_device_diagnostics_config ===

   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;

   struct DeviceDiagnosticsConfigCreateInfoNV;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_NV_cuda_kernel_launch ===

   struct CudaModuleCreateInfoNV;

   struct CudaFunctionCreateInfoNV;

   struct CudaLaunchInfoNV;

   struct PhysicalDeviceCudaKernelLaunchFeaturesNV;

   struct PhysicalDeviceCudaKernelLaunchPropertiesNV;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_NV_low_latency ===

   struct QueryLowLatencySupportNV;


 #if defined( VK_USE_PLATFORM_METAL_EXT )

   //=== VK_EXT_metal_objects ===

   struct ExportMetalObjectCreateInfoEXT;

   struct ExportMetalObjectsInfoEXT;

   struct ExportMetalDeviceInfoEXT;

   struct ExportMetalCommandQueueInfoEXT;

   struct ExportMetalBufferInfoEXT;

   struct ImportMetalBufferInfoEXT;

   struct ExportMetalTextureInfoEXT;

   struct ImportMetalTextureInfoEXT;

   struct ExportMetalIOSurfaceInfoEXT;

   struct ImportMetalIOSurfaceInfoEXT;

   struct ExportMetalSharedEventInfoEXT;

   struct ImportMetalSharedEventInfoEXT;

 #endif /*VK_USE_PLATFORM_METAL_EXT*/


   //=== VK_KHR_synchronization2 ===

   struct QueueFamilyCheckpointProperties2NV;

   struct CheckpointData2NV;


   //=== VK_EXT_descriptor_buffer ===

   struct PhysicalDeviceDescriptorBufferPropertiesEXT;

   struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;

   struct PhysicalDeviceDescriptorBufferFeaturesEXT;

   struct DescriptorAddressInfoEXT;

   struct DescriptorBufferBindingInfoEXT;

   struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;

   union DescriptorDataEXT;

   struct DescriptorGetInfoEXT;

   struct BufferCaptureDescriptorDataInfoEXT;

   struct ImageCaptureDescriptorDataInfoEXT;

   struct ImageViewCaptureDescriptorDataInfoEXT;

   struct SamplerCaptureDescriptorDataInfoEXT;

   struct OpaqueCaptureDescriptorDataCreateInfoEXT;

   struct AccelerationStructureCaptureDescriptorDataInfoEXT;


   //=== VK_EXT_graphics_pipeline_library ===

   struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;

   struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;

   struct GraphicsPipelineLibraryCreateInfoEXT;


   //=== VK_AMD_shader_early_and_late_fragment_tests ===

   struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;


   //=== VK_KHR_fragment_shader_barycentric ===

   struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

   using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

   struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;


   //=== VK_KHR_shader_subgroup_uniform_control_flow ===

   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;


   //=== VK_NV_fragment_shading_rate_enums ===

   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;

   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;

   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;


   //=== VK_NV_ray_tracing_motion_blur ===

   struct AccelerationStructureGeometryMotionTrianglesDataNV;

   struct AccelerationStructureMotionInfoNV;

   struct AccelerationStructureMotionInstanceNV;

   union AccelerationStructureMotionInstanceDataNV;

   struct AccelerationStructureMatrixMotionInstanceNV;

   struct AccelerationStructureSRTMotionInstanceNV;

   struct SRTDataNV;

   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;


   //=== VK_EXT_mesh_shader ===

   struct PhysicalDeviceMeshShaderFeaturesEXT;

   struct PhysicalDeviceMeshShaderPropertiesEXT;

   struct DrawMeshTasksIndirectCommandEXT;


   //=== VK_EXT_ycbcr_2plane_444_formats ===

   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;


   //=== VK_EXT_fragment_density_map2 ===

   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;

   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;


   //=== VK_QCOM_rotated_copy_commands ===

   struct CopyCommandTransformInfoQCOM;


   //=== VK_KHR_workgroup_memory_explicit_layout ===

   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;


   //=== VK_EXT_image_compression_control ===

   struct PhysicalDeviceImageCompressionControlFeaturesEXT;

   struct ImageCompressionControlEXT;

   struct ImageCompressionPropertiesEXT;


   //=== VK_EXT_attachment_feedback_loop_layout ===

   struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;


   //=== VK_EXT_4444_formats ===

   struct PhysicalDevice4444FormatsFeaturesEXT;


   //=== VK_EXT_device_fault ===

   struct PhysicalDeviceFaultFeaturesEXT;

   struct DeviceFaultCountsEXT;

   struct DeviceFaultInfoEXT;

   struct DeviceFaultAddressInfoEXT;

   struct DeviceFaultVendorInfoEXT;

   struct DeviceFaultVendorBinaryHeaderVersionOneEXT;


   //=== VK_EXT_rgba10x6_formats ===

   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

   //=== VK_EXT_directfb_surface ===

   struct DirectFBSurfaceCreateInfoEXT;

 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/


   //=== VK_EXT_vertex_input_dynamic_state ===

   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;

   struct VertexInputBindingDescription2EXT;

   struct VertexInputAttributeDescription2EXT;


   //=== VK_EXT_physical_device_drm ===

   struct PhysicalDeviceDrmPropertiesEXT;


   //=== VK_EXT_device_address_binding_report ===

   struct PhysicalDeviceAddressBindingReportFeaturesEXT;

   struct DeviceAddressBindingCallbackDataEXT;


   //=== VK_EXT_depth_clip_control ===

   struct PhysicalDeviceDepthClipControlFeaturesEXT;

   struct PipelineViewportDepthClipControlCreateInfoEXT;


   //=== VK_EXT_primitive_topology_list_restart ===

   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_external_memory ===

   struct ImportMemoryZirconHandleInfoFUCHSIA;

   struct MemoryZirconHandlePropertiesFUCHSIA;

   struct MemoryGetZirconHandleInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_external_semaphore ===

   struct ImportSemaphoreZirconHandleInfoFUCHSIA;

   struct SemaphoreGetZirconHandleInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_buffer_collection ===

   struct BufferCollectionCreateInfoFUCHSIA;

   struct ImportMemoryBufferCollectionFUCHSIA;

   struct BufferCollectionImageCreateInfoFUCHSIA;

   struct BufferConstraintsInfoFUCHSIA;

   struct BufferCollectionBufferCreateInfoFUCHSIA;

   struct BufferCollectionPropertiesFUCHSIA;

   struct SysmemColorSpaceFUCHSIA;

   struct ImageConstraintsInfoFUCHSIA;

   struct ImageFormatConstraintsInfoFUCHSIA;

   struct BufferCollectionConstraintsInfoFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


   //=== VK_HUAWEI_subpass_shading ===

   struct SubpassShadingPipelineCreateInfoHUAWEI;

   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;

   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;


   //=== VK_HUAWEI_invocation_mask ===

   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;


   //=== VK_NV_external_memory_rdma ===

   struct MemoryGetRemoteAddressInfoNV;

   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;


   //=== VK_EXT_pipeline_properties ===

   struct PipelinePropertiesIdentifierEXT;

   struct PhysicalDevicePipelinePropertiesFeaturesEXT;


   //=== VK_EXT_frame_boundary ===

   struct PhysicalDeviceFrameBoundaryFeaturesEXT;

   struct FrameBoundaryEXT;


   //=== VK_EXT_multisampled_render_to_single_sampled ===

   struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;

   struct SubpassResolvePerformanceQueryEXT;

   struct MultisampledRenderToSingleSampledInfoEXT;


   //=== VK_EXT_extended_dynamic_state2 ===

   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

   //=== VK_QNX_screen_surface ===

   struct ScreenSurfaceCreateInfoQNX;

 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


   //=== VK_EXT_color_write_enable ===

   struct PhysicalDeviceColorWriteEnableFeaturesEXT;

   struct PipelineColorWriteCreateInfoEXT;


   //=== VK_EXT_primitives_generated_query ===

   struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;


   //=== VK_KHR_ray_tracing_maintenance1 ===

   struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;

   struct TraceRaysIndirectCommand2KHR;


   //=== VK_EXT_image_view_min_lod ===

   struct PhysicalDeviceImageViewMinLodFeaturesEXT;

   struct ImageViewMinLodCreateInfoEXT;


   //=== VK_EXT_multi_draw ===

   struct PhysicalDeviceMultiDrawFeaturesEXT;

   struct PhysicalDeviceMultiDrawPropertiesEXT;

   struct MultiDrawInfoEXT;

   struct MultiDrawIndexedInfoEXT;


   //=== VK_EXT_image_2d_view_of_3d ===

   struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;


   //=== VK_EXT_shader_tile_image ===

   struct PhysicalDeviceShaderTileImageFeaturesEXT;

   struct PhysicalDeviceShaderTileImagePropertiesEXT;


   //=== VK_EXT_opacity_micromap ===

   struct MicromapBuildInfoEXT;

   struct MicromapUsageEXT;

   struct MicromapCreateInfoEXT;

   struct PhysicalDeviceOpacityMicromapFeaturesEXT;

   struct PhysicalDeviceOpacityMicromapPropertiesEXT;

   struct MicromapVersionInfoEXT;

   struct CopyMicromapToMemoryInfoEXT;

   struct CopyMemoryToMicromapInfoEXT;

   struct CopyMicromapInfoEXT;

   struct MicromapBuildSizesInfoEXT;

   struct AccelerationStructureTrianglesOpacityMicromapEXT;

   struct MicromapTriangleEXT;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_NV_displacement_micromap ===

   struct PhysicalDeviceDisplacementMicromapFeaturesNV;

   struct PhysicalDeviceDisplacementMicromapPropertiesNV;

   struct AccelerationStructureTrianglesDisplacementMicromapNV;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   //=== VK_HUAWEI_cluster_culling_shader ===

   struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;

   struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;

   struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;


   //=== VK_EXT_border_color_swizzle ===

   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;

   struct SamplerBorderColorComponentMappingCreateInfoEXT;


   //=== VK_EXT_pageable_device_local_memory ===

   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;


   //=== VK_ARM_shader_core_properties ===

   struct PhysicalDeviceShaderCorePropertiesARM;


   //=== VK_ARM_scheduling_controls ===

   struct DeviceQueueShaderCoreControlCreateInfoARM;

   struct PhysicalDeviceSchedulingControlsFeaturesARM;

   struct PhysicalDeviceSchedulingControlsPropertiesARM;


   //=== VK_EXT_image_sliced_view_of_3d ===

   struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;

   struct ImageViewSlicedCreateInfoEXT;


   //=== VK_VALVE_descriptor_set_host_mapping ===

   struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;

   struct DescriptorSetBindingReferenceVALVE;

   struct DescriptorSetLayoutHostMappingInfoVALVE;


   //=== VK_EXT_depth_clamp_zero_one ===

   struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;


   //=== VK_EXT_non_seamless_cube_map ===

   struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;


   //=== VK_ARM_render_pass_striped ===

   struct PhysicalDeviceRenderPassStripedFeaturesARM;

   struct PhysicalDeviceRenderPassStripedPropertiesARM;

   struct RenderPassStripeBeginInfoARM;

   struct RenderPassStripeInfoARM;

   struct RenderPassStripeSubmitInfoARM;


   //=== VK_QCOM_fragment_density_map_offset ===

   struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;

   struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;

   struct SubpassFragmentDensityMapOffsetEndInfoQCOM;


   //=== VK_NV_copy_memory_indirect ===

   struct CopyMemoryIndirectCommandNV;

   struct CopyMemoryToImageIndirectCommandNV;

   struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;

   struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;


   //=== VK_NV_memory_decompression ===

   struct DecompressMemoryRegionNV;

   struct PhysicalDeviceMemoryDecompressionFeaturesNV;

   struct PhysicalDeviceMemoryDecompressionPropertiesNV;


   //=== VK_NV_device_generated_commands_compute ===

   struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;

   struct ComputePipelineIndirectBufferInfoNV;

   struct PipelineIndirectDeviceAddressInfoNV;

   struct BindPipelineIndirectCommandNV;


   //=== VK_NV_linear_color_attachment ===

   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;


   //=== VK_EXT_image_compression_control_swapchain ===

   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;


   //=== VK_QCOM_image_processing ===

   struct ImageViewSampleWeightCreateInfoQCOM;

   struct PhysicalDeviceImageProcessingFeaturesQCOM;

   struct PhysicalDeviceImageProcessingPropertiesQCOM;


   //=== VK_EXT_nested_command_buffer ===

   struct PhysicalDeviceNestedCommandBufferFeaturesEXT;

   struct PhysicalDeviceNestedCommandBufferPropertiesEXT;


   //=== VK_EXT_external_memory_acquire_unmodified ===

   struct ExternalMemoryAcquireUnmodifiedEXT;


   //=== VK_EXT_extended_dynamic_state3 ===

   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;

   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;

   struct ColorBlendEquationEXT;

   struct ColorBlendAdvancedEXT;


   //=== VK_EXT_subpass_merge_feedback ===

   struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;

   struct RenderPassCreationControlEXT;

   struct RenderPassCreationFeedbackInfoEXT;

   struct RenderPassCreationFeedbackCreateInfoEXT;

   struct RenderPassSubpassFeedbackInfoEXT;

   struct RenderPassSubpassFeedbackCreateInfoEXT;


   //=== VK_LUNARG_direct_driver_loading ===

   struct DirectDriverLoadingInfoLUNARG;

   struct DirectDriverLoadingListLUNARG;


   //=== VK_EXT_shader_module_identifier ===

   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;

   struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;

   struct PipelineShaderStageModuleIdentifierCreateInfoEXT;

   struct ShaderModuleIdentifierEXT;


   //=== VK_EXT_rasterization_order_attachment_access ===

   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;

   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;


   //=== VK_NV_optical_flow ===

   struct PhysicalDeviceOpticalFlowFeaturesNV;

   struct PhysicalDeviceOpticalFlowPropertiesNV;

   struct OpticalFlowImageFormatInfoNV;

   struct OpticalFlowImageFormatPropertiesNV;

   struct OpticalFlowSessionCreateInfoNV;

   struct OpticalFlowSessionCreatePrivateDataInfoNV;

   struct OpticalFlowExecuteInfoNV;


   //=== VK_EXT_legacy_dithering ===

   struct PhysicalDeviceLegacyDitheringFeaturesEXT;


   //=== VK_EXT_pipeline_protected_access ===

   struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

   //=== VK_ANDROID_external_format_resolve ===

   struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;

   struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;

   struct AndroidHardwareBufferFormatResolvePropertiesANDROID;

 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


   //=== VK_KHR_maintenance5 ===

   struct PhysicalDeviceMaintenance5FeaturesKHR;

   struct PhysicalDeviceMaintenance5PropertiesKHR;

   struct RenderingAreaInfoKHR;

   struct DeviceImageSubresourceInfoKHR;

   struct ImageSubresource2KHR;

   using ImageSubresource2EXT = ImageSubresource2KHR;

   struct SubresourceLayout2KHR;

   using SubresourceLayout2EXT = SubresourceLayout2KHR;

   struct PipelineCreateFlags2CreateInfoKHR;

   struct BufferUsageFlags2CreateInfoKHR;


   //=== VK_KHR_ray_tracing_position_fetch ===

   struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;


   //=== VK_EXT_shader_object ===

   struct PhysicalDeviceShaderObjectFeaturesEXT;

   struct PhysicalDeviceShaderObjectPropertiesEXT;

   struct ShaderCreateInfoEXT;


   //=== VK_QCOM_tile_properties ===

   struct PhysicalDeviceTilePropertiesFeaturesQCOM;

   struct TilePropertiesQCOM;


   //=== VK_SEC_amigo_profiling ===

   struct PhysicalDeviceAmigoProfilingFeaturesSEC;

   struct AmigoProfilingSubmitInfoSEC;


   //=== VK_QCOM_multiview_per_view_viewports ===

   struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;


   //=== VK_NV_ray_tracing_invocation_reorder ===

   struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;

   struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;


   //=== VK_NV_extended_sparse_address_space ===

   struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;

   struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;


   //=== VK_EXT_mutable_descriptor_type ===

   struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

   using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

   struct MutableDescriptorTypeListEXT;

   using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;

   struct MutableDescriptorTypeCreateInfoEXT;

   using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;


   //=== VK_EXT_layer_settings ===

   struct LayerSettingsCreateInfoEXT;

   struct LayerSettingEXT;


   //=== VK_ARM_shader_core_builtins ===

   struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;

   struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;


   //=== VK_EXT_pipeline_library_group_handles ===

   struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;


   //=== VK_EXT_dynamic_rendering_unused_attachments ===

   struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;


   //=== VK_NV_low_latency2 ===

   struct LatencySleepModeInfoNV;

   struct LatencySleepInfoNV;

   struct SetLatencyMarkerInfoNV;

   struct GetLatencyMarkerInfoNV;

   struct LatencyTimingsFrameReportNV;

   struct LatencySubmissionPresentIdNV;

   struct SwapchainLatencyCreateInfoNV;

   struct OutOfBandQueueTypeInfoNV;

   struct LatencySurfaceCapabilitiesNV;


   //=== VK_KHR_cooperative_matrix ===

   struct CooperativeMatrixPropertiesKHR;

   struct PhysicalDeviceCooperativeMatrixFeaturesKHR;

   struct PhysicalDeviceCooperativeMatrixPropertiesKHR;


   //=== VK_QCOM_multiview_per_view_render_areas ===

   struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;

   struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;


   //=== VK_KHR_video_maintenance1 ===

   struct PhysicalDeviceVideoMaintenance1FeaturesKHR;

   struct VideoInlineQueryInfoKHR;


   //=== VK_NV_per_stage_descriptor_set ===

   struct PhysicalDevicePerStageDescriptorSetFeaturesNV;


   //=== VK_QCOM_image_processing2 ===

   struct PhysicalDeviceImageProcessing2FeaturesQCOM;

   struct PhysicalDeviceImageProcessing2PropertiesQCOM;

   struct SamplerBlockMatchWindowCreateInfoQCOM;


   //=== VK_QCOM_filter_cubic_weights ===

   struct PhysicalDeviceCubicWeightsFeaturesQCOM;

   struct SamplerCubicWeightsCreateInfoQCOM;

   struct BlitImageCubicWeightsInfoQCOM;


   //=== VK_QCOM_ycbcr_degamma ===

   struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;

   struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;


   //=== VK_QCOM_filter_cubic_clamp ===

   struct PhysicalDeviceCubicClampFeaturesQCOM;


   //=== VK_EXT_attachment_feedback_loop_dynamic_state ===

   struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;


   //=== VK_KHR_vertex_attribute_divisor ===

   struct PhysicalDeviceVertexAttributeDivisorPropertiesKHR;

   struct VertexInputBindingDivisorDescriptionKHR;

   using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescriptionKHR;

   struct PipelineVertexInputDivisorStateCreateInfoKHR;

   using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfoKHR;

   struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR;

   using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeaturesKHR;


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

   //=== VK_QNX_external_memory_screen_buffer ===

   struct ScreenBufferPropertiesQNX;

   struct ScreenBufferFormatPropertiesQNX;

   struct ImportScreenBufferInfoQNX;

   struct ExternalFormatQNX;

   struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;

 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


   //=== VK_MSFT_layered_driver ===

   struct PhysicalDeviceLayeredDriverPropertiesMSFT;


   //=== VK_KHR_calibrated_timestamps ===

   struct CalibratedTimestampInfoKHR;

   using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;


   //=== VK_KHR_maintenance6 ===

   struct PhysicalDeviceMaintenance6FeaturesKHR;

   struct PhysicalDeviceMaintenance6PropertiesKHR;

   struct BindMemoryStatusKHR;

   struct BindDescriptorSetsInfoKHR;

   struct PushConstantsInfoKHR;

   struct PushDescriptorSetInfoKHR;

   struct PushDescriptorSetWithTemplateInfoKHR;

   struct SetDescriptorBufferOffsetsInfoEXT;

   struct BindDescriptorBufferEmbeddedSamplersInfoEXT;


   //=== VK_NV_descriptor_pool_overallocation ===

   struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;


   //===================================

   //=== HANDLE forward declarations ===

   //===================================


   //=== VK_VERSION_1_0 ===

   class Instance;

   class PhysicalDevice;

   class Device;

   class Queue;

   class DeviceMemory;

   class Fence;

   class Semaphore;

   class Event;

   class QueryPool;

   class Buffer;

   class BufferView;

   class Image;

   class ImageView;

   class ShaderModule;

   class PipelineCache;

   class Pipeline;

   class PipelineLayout;

   class Sampler;

   class DescriptorPool;

   class DescriptorSet;

   class DescriptorSetLayout;

   class Framebuffer;

   class RenderPass;

   class CommandPool;

   class CommandBuffer;


   //=== VK_VERSION_1_1 ===

   class SamplerYcbcrConversion;

   class DescriptorUpdateTemplate;


   //=== VK_VERSION_1_3 ===

   class PrivateDataSlot;


   //=== VK_KHR_surface ===

   class SurfaceKHR;


   //=== VK_KHR_swapchain ===

   class SwapchainKHR;


   //=== VK_KHR_display ===

   class DisplayKHR;

   class DisplayModeKHR;


   //=== VK_EXT_debug_report ===

   class DebugReportCallbackEXT;


   //=== VK_KHR_video_queue ===

   class VideoSessionKHR;

   class VideoSessionParametersKHR;


   //=== VK_NVX_binary_import ===

   class CuModuleNVX;

   class CuFunctionNVX;


   //=== VK_EXT_debug_utils ===

   class DebugUtilsMessengerEXT;


   //=== VK_KHR_acceleration_structure ===

   class AccelerationStructureKHR;


   //=== VK_EXT_validation_cache ===

   class ValidationCacheEXT;


   //=== VK_NV_ray_tracing ===

   class AccelerationStructureNV;


   //=== VK_INTEL_performance_query ===

   class PerformanceConfigurationINTEL;


   //=== VK_KHR_deferred_host_operations ===

   class DeferredOperationKHR;


   //=== VK_NV_device_generated_commands ===

   class IndirectCommandsLayoutNV;


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_NV_cuda_kernel_launch ===

   class CudaModuleNV;

   class CudaFunctionNV;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_buffer_collection ===

   class BufferCollectionFUCHSIA;

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


   //=== VK_EXT_opacity_micromap ===

   class MicromapEXT;


   //=== VK_NV_optical_flow ===

   class OpticalFlowSessionNV;


   //=== VK_EXT_shader_object ===

   class ShaderEXT;


 #ifndef VULKAN_HPP_NO_SMART_HANDLE

   //======================

   //=== UNIQUE HANDLEs ===

   //======================


   //=== VK_VERSION_1_0 ===

   template <typename Dispatch>

   class UniqueHandleTraits<Instance, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<NoParent, Dispatch>;

   };


   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Device, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<NoParent, Dispatch>;

   };


   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<DeviceMemory, Dispatch>

   {

   public:

     using deleter = ObjectFree<Device, Dispatch>;

   };


   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Fence, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Semaphore, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Event, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<QueryPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Buffer, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<BufferView, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Image, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<ImageView, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<ShaderModule, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<PipelineCache, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Pipeline, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<PipelineLayout, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Sampler, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorSet, Dispatch>

   {

   public:

     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;

   };


   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<Framebuffer, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<RenderPass, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<CommandPool, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<CommandBuffer, Dispatch>

   {

   public:

     using deleter = PoolFree<Device, CommandPool, Dispatch>;

   };


   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_VERSION_1_1 ===

   template <typename Dispatch>

   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_VERSION_1_3 ===

   template <typename Dispatch>

   class UniqueHandleTraits<PrivateDataSlot, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_surface ===

   template <typename Dispatch>

   class UniqueHandleTraits<SurfaceKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };


   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_swapchain ===

   template <typename Dispatch>

   class UniqueHandleTraits<SwapchainKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_display ===

   template <typename Dispatch>

   class UniqueHandleTraits<DisplayKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;

   };


   using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_EXT_debug_report ===

   template <typename Dispatch>

   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };


   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_video_queue ===

   template <typename Dispatch>

   class UniqueHandleTraits<VideoSessionKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_NVX_binary_import ===

   template <typename Dispatch>

   class UniqueHandleTraits<CuModuleNVX, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<CuFunctionNVX, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_EXT_debug_utils ===

   template <typename Dispatch>

   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Instance, Dispatch>;

   };


   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_acceleration_structure ===

   template <typename Dispatch>

   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_EXT_validation_cache ===

   template <typename Dispatch>

   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_NV_ray_tracing ===

   template <typename Dispatch>

   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_INTEL_performance_query ===

   template <typename Dispatch>

   class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_KHR_deferred_host_operations ===

   template <typename Dispatch>

   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_NV_device_generated_commands ===

   template <typename Dispatch>

   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


 #  if defined( VK_ENABLE_BETA_EXTENSIONS )

   //=== VK_NV_cuda_kernel_launch ===

   template <typename Dispatch>

   class UniqueHandleTraits<CudaModuleNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   template <typename Dispatch>

   class UniqueHandleTraits<CudaFunctionNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #  if defined( VK_USE_PLATFORM_FUCHSIA )

   //=== VK_FUCHSIA_buffer_collection ===

   template <typename Dispatch>

   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #  endif /*VK_USE_PLATFORM_FUCHSIA*/


   //=== VK_EXT_opacity_micromap ===

   template <typename Dispatch>

   class UniqueHandleTraits<MicromapEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_NV_optical_flow ===

   template <typename Dispatch>

   class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


   //=== VK_EXT_shader_object ===

   template <typename Dispatch>

   class UniqueHandleTraits<ShaderEXT, Dispatch>

   {

   public:

     using deleter = ObjectDestroy<Device, Dispatch>;

   };


   using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/


   //===============

   //=== HANDLEs ===

   //===============


   template <typename Type>

   struct isVulkanHandleType

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;

   };


   class SurfaceKHR

   {

   public:

     using CType      = VkSurfaceKHR;

     using NativeType = VkSurfaceKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;


   public:

     VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;


     VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_surfaceKHR = surfaceKHR;

       return *this;

     }

 #endif


     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_surfaceKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SurfaceKHR const & ) const = default;

 #else

     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR == rhs.m_surfaceKHR;

     }


     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR != rhs.m_surfaceKHR;

     }


     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR < rhs.m_surfaceKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_surfaceKHR == VK_NULL_HANDLE;

     }


   private:

     VkSurfaceKHR m_surfaceKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DebugReportCallbackEXT

   {

   public:

     using CType      = VkDebugReportCallbackEXT;

     using NativeType = VkDebugReportCallbackEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;


   public:

     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;


     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT

       : m_debugReportCallbackEXT( debugReportCallbackEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_debugReportCallbackEXT = debugReportCallbackEXT;

       return *this;

     }

 #endif


     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_debugReportCallbackEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DebugReportCallbackEXT const & ) const = default;

 #else

     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;

     }


     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;

     }


     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugReportCallbackEXT == VK_NULL_HANDLE;

     }


   private:

     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DebugUtilsMessengerEXT

   {

   public:

     using CType      = VkDebugUtilsMessengerEXT;

     using NativeType = VkDebugUtilsMessengerEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;


     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT

       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;

       return *this;

     }

 #endif


     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_debugUtilsMessengerEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;

 #else

     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;

     }


     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;

     }


     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;

     }


   private:

     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DisplayKHR

   {

   public:

     using CType      = VkDisplayKHR;

     using NativeType = VkDisplayKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;


   public:

     VULKAN_HPP_CONSTEXPR DisplayKHR() = default;


     VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_displayKHR = displayKHR;

       return *this;

     }

 #endif


     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_displayKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DisplayKHR const & ) const = default;

 #else

     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR == rhs.m_displayKHR;

     }


     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR != rhs.m_displayKHR;

     }


     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR < rhs.m_displayKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayKHR == VK_NULL_HANDLE;

     }


   private:

     VkDisplayKHR m_displayKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class SwapchainKHR

   {

   public:

     using CType      = VkSwapchainKHR;

     using NativeType = VkSwapchainKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;


   public:

     VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;


     VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_swapchainKHR = swapchainKHR;

       return *this;

     }

 #endif


     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_swapchainKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SwapchainKHR const & ) const = default;

 #else

     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR == rhs.m_swapchainKHR;

     }


     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR != rhs.m_swapchainKHR;

     }


     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR < rhs.m_swapchainKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_swapchainKHR == VK_NULL_HANDLE;

     }


   private:

     VkSwapchainKHR m_swapchainKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Semaphore

   {

   public:

     using CType      = VkSemaphore;

     using NativeType = VkSemaphore;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;


   public:

     VULKAN_HPP_CONSTEXPR Semaphore() = default;


     VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT

     {

       m_semaphore = semaphore;

       return *this;

     }

 #endif


     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_semaphore = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Semaphore const & ) const = default;

 #else

     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore == rhs.m_semaphore;

     }


     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore != rhs.m_semaphore;

     }


     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore < rhs.m_semaphore;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_semaphore == VK_NULL_HANDLE;

     }


   private:

     VkSemaphore m_semaphore = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>

   {

     using Type = VULKAN_HPP_NAMESPACE::Semaphore;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>

   {

     using Type = VULKAN_HPP_NAMESPACE::Semaphore;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Fence

   {

   public:

     using CType      = VkFence;

     using NativeType = VkFence;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;


   public:

     VULKAN_HPP_CONSTEXPR Fence() = default;


     VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT

     {

       m_fence = fence;

       return *this;

     }

 #endif


     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_fence = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Fence const & ) const = default;

 #else

     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence == rhs.m_fence;

     }


     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence != rhs.m_fence;

     }


     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_fence < rhs.m_fence;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_fence == VK_NULL_HANDLE;

     }


   private:

     VkFence m_fence = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>

   {

     using Type = VULKAN_HPP_NAMESPACE::Fence;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>

   {

     using Type = VULKAN_HPP_NAMESPACE::Fence;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PerformanceConfigurationINTEL

   {

   public:

     using CType      = VkPerformanceConfigurationINTEL;

     using NativeType = VkPerformanceConfigurationINTEL;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;


     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT

       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT

     {

       m_performanceConfigurationINTEL = performanceConfigurationINTEL;

       return *this;

     }

 #endif


     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_performanceConfigurationINTEL = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;

 #else

     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;

     }


     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;

     }


     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;

     }


   private:

     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>

   {

     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class QueryPool

   {

   public:

     using CType      = VkQueryPool;

     using NativeType = VkQueryPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;


   public:

     VULKAN_HPP_CONSTEXPR QueryPool() = default;


     VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT

     {

       m_queryPool = queryPool;

       return *this;

     }

 #endif


     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_queryPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( QueryPool const & ) const = default;

 #else

     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool == rhs.m_queryPool;

     }


     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool != rhs.m_queryPool;

     }


     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool < rhs.m_queryPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_queryPool == VK_NULL_HANDLE;

     }


   private:

     VkQueryPool m_queryPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::QueryPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::QueryPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Buffer

   {

   public:

     using CType      = VkBuffer;

     using NativeType = VkBuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;


   public:

     VULKAN_HPP_CONSTEXPR Buffer() = default;


     VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT

     {

       m_buffer = buffer;

       return *this;

     }

 #endif


     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_buffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Buffer const & ) const = default;

 #else

     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer == rhs.m_buffer;

     }


     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer != rhs.m_buffer;

     }


     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer < rhs.m_buffer;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_buffer == VK_NULL_HANDLE;

     }


   private:

     VkBuffer m_buffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Buffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Buffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PipelineLayout

   {

   public:

     using CType      = VkPipelineLayout;

     using NativeType = VkPipelineLayout;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;


   public:

     VULKAN_HPP_CONSTEXPR PipelineLayout() = default;


     VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineLayout = pipelineLayout;

       return *this;

     }

 #endif


     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineLayout = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PipelineLayout const & ) const = default;

 #else

     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout == rhs.m_pipelineLayout;

     }


     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout != rhs.m_pipelineLayout;

     }


     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout < rhs.m_pipelineLayout;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineLayout == VK_NULL_HANDLE;

     }


   private:

     VkPipelineLayout m_pipelineLayout = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorSet

   {

   public:

     using CType      = VkDescriptorSet;

     using NativeType = VkDescriptorSet;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;


   public:

     VULKAN_HPP_CONSTEXPR DescriptorSet() = default;


     VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSet = descriptorSet;

       return *this;

     }

 #endif


     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSet = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorSet const & ) const = default;

 #else

     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet == rhs.m_descriptorSet;

     }


     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet != rhs.m_descriptorSet;

     }


     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet < rhs.m_descriptorSet;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSet == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorSet m_descriptorSet = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class ImageView

   {

   public:

     using CType      = VkImageView;

     using NativeType = VkImageView;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;


   public:

     VULKAN_HPP_CONSTEXPR ImageView() = default;


     VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT

     {

       m_imageView = imageView;

       return *this;

     }

 #endif


     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_imageView = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ImageView const & ) const = default;

 #else

     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView == rhs.m_imageView;

     }


     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView != rhs.m_imageView;

     }


     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView < rhs.m_imageView;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_imageView == VK_NULL_HANDLE;

     }


   private:

     VkImageView m_imageView = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>

   {

     using Type = VULKAN_HPP_NAMESPACE::ImageView;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>

   {

     using Type = VULKAN_HPP_NAMESPACE::ImageView;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Pipeline

   {

   public:

     using CType      = VkPipeline;

     using NativeType = VkPipeline;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;


   public:

     VULKAN_HPP_CONSTEXPR Pipeline() = default;


     VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT

     {

       m_pipeline = pipeline;

       return *this;

     }

 #endif


     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipeline = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Pipeline const & ) const = default;

 #else

     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline == rhs.m_pipeline;

     }


     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline != rhs.m_pipeline;

     }


     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline < rhs.m_pipeline;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipeline == VK_NULL_HANDLE;

     }


   private:

     VkPipeline m_pipeline = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>

   {

     using Type = VULKAN_HPP_NAMESPACE::Pipeline;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>

   {

     using Type = VULKAN_HPP_NAMESPACE::Pipeline;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class ShaderEXT

   {

   public:

     using CType      = VkShaderEXT;

     using NativeType = VkShaderEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR ShaderEXT() = default;


     VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderEXT = shaderEXT;

       return *this;

     }

 #endif


     ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ShaderEXT const & ) const = default;

 #else

     bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT == rhs.m_shaderEXT;

     }


     bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT != rhs.m_shaderEXT;

     }


     bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT < rhs.m_shaderEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderEXT == VK_NULL_HANDLE;

     }


   private:

     VkShaderEXT m_shaderEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Image

   {

   public:

     using CType      = VkImage;

     using NativeType = VkImage;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;


   public:

     VULKAN_HPP_CONSTEXPR Image() = default;


     VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT

     {

       m_image = image;

       return *this;

     }

 #endif


     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_image = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Image const & ) const = default;

 #else

     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image == rhs.m_image;

     }


     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image != rhs.m_image;

     }


     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_image < rhs.m_image;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT

     {

       return m_image;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_image != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_image == VK_NULL_HANDLE;

     }


   private:

     VkImage m_image = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>

   {

     using Type = VULKAN_HPP_NAMESPACE::Image;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>

   {

     using Type = VULKAN_HPP_NAMESPACE::Image;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class AccelerationStructureNV

   {

   public:

     using CType      = VkAccelerationStructureNV;

     using NativeType = VkAccelerationStructureNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;


   public:

     VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;


     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT

       : m_accelerationStructureNV( accelerationStructureNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureNV = accelerationStructureNV;

       return *this;

     }

 #endif


     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( AccelerationStructureNV const & ) const = default;

 #else

     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;

     }


     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;

     }


     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureNV == VK_NULL_HANDLE;

     }


   private:

     VkAccelerationStructureNV m_accelerationStructureNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class OpticalFlowSessionNV

   {

   public:

     using CType      = VkOpticalFlowSessionNV;

     using NativeType = VkOpticalFlowSessionNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV() = default;


     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT

       : m_opticalFlowSessionNV( opticalFlowSessionNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT

     {

       m_opticalFlowSessionNV = opticalFlowSessionNV;

       return *this;

     }

 #endif


     OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_opticalFlowSessionNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( OpticalFlowSessionNV const & ) const = default;

 #else

     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;

     }


     bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;

     }


     bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_opticalFlowSessionNV == VK_NULL_HANDLE;

     }


   private:

     VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorUpdateTemplate

   {

   public:

     using CType      = VkDescriptorUpdateTemplate;

     using NativeType = VkDescriptorUpdateTemplate;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;


   public:

     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;


     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT

       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorUpdateTemplate = descriptorUpdateTemplate;

       return *this;

     }

 #endif


     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorUpdateTemplate = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;

 #else

     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;

     }


     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;

     }


     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;


   class Event

   {

   public:

     using CType      = VkEvent;

     using NativeType = VkEvent;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;


   public:

     VULKAN_HPP_CONSTEXPR Event() = default;


     VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT

     {

       m_event = event;

       return *this;

     }

 #endif


     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_event = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Event const & ) const = default;

 #else

     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event == rhs.m_event;

     }


     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event != rhs.m_event;

     }


     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_event < rhs.m_event;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT

     {

       return m_event;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_event != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_event == VK_NULL_HANDLE;

     }


   private:

     VkEvent m_event = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>

   {

     using Type = VULKAN_HPP_NAMESPACE::Event;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>

   {

     using Type = VULKAN_HPP_NAMESPACE::Event;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class AccelerationStructureKHR

   {

   public:

     using CType      = VkAccelerationStructureKHR;

     using NativeType = VkAccelerationStructureKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;


   public:

     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;


     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT

       : m_accelerationStructureKHR( accelerationStructureKHR )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureKHR = accelerationStructureKHR;

       return *this;

     }

 #endif


     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_accelerationStructureKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( AccelerationStructureKHR const & ) const = default;

 #else

     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;

     }


     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;

     }


     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_accelerationStructureKHR == VK_NULL_HANDLE;

     }


   private:

     VkAccelerationStructureKHR m_accelerationStructureKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class MicromapEXT

   {

   public:

     using CType      = VkMicromapEXT;

     using NativeType = VkMicromapEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR MicromapEXT() = default;


     VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_micromapEXT = micromapEXT;

       return *this;

     }

 #endif


     MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_micromapEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( MicromapEXT const & ) const = default;

 #else

     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT == rhs.m_micromapEXT;

     }


     bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT != rhs.m_micromapEXT;

     }


     bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT < rhs.m_micromapEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_micromapEXT == VK_NULL_HANDLE;

     }


   private:

     VkMicromapEXT m_micromapEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CommandBuffer

   {

   public:

     using CType      = VkCommandBuffer;

     using NativeType = VkCommandBuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;


   public:

     VULKAN_HPP_CONSTEXPR CommandBuffer() = default;


     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}


     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT

     {

       m_commandBuffer = commandBuffer;

       return *this;

     }


     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_commandBuffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CommandBuffer const & ) const = default;

 #else

     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer == rhs.m_commandBuffer;

     }


     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer != rhs.m_commandBuffer;

     }


     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer < rhs.m_commandBuffer;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,

                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,

                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,

                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewport( uint32_t                               firstViewport,

                       uint32_t                               viewportCount,

                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,

                       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewport( uint32_t                                                                       firstViewport,

                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,

                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissor( uint32_t                             firstScissor,

                      uint32_t                             scissorCount,

                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,

                      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissor( uint32_t                                                                     firstScissor,

                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,

                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBias( float              depthBiasConstantFactor,

                        float              depthBiasClamp,

                        float              depthBiasSlopeFactor,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                                 uint32_t                               compareMask,

                                 Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                               uint32_t                               writeMask,

                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                               uint32_t                               reference,

                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,

                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,

                              uint32_t                                    firstSet,

                              uint32_t                                    descriptorSetCount,

                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,

                              uint32_t                                    dynamicOffsetCount,

                              const uint32_t *                            pDynamicOffsets,

                              Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                             pipelineBindPoint,

                              VULKAN_HPP_NAMESPACE::PipelineLayout                                                layout,

                              uint32_t                                                                            firstSet,

                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,

                              VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                            dynamicOffsets,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                           VULKAN_HPP_NAMESPACE::DeviceSize offset,

                           VULKAN_HPP_NAMESPACE::IndexType  indexType,

                           Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers( uint32_t                                 firstBinding,

                             uint32_t                                 bindingCount,

                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,

                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers( uint32_t                                                                         firstBinding,

                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,

                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void draw( uint32_t           vertexCount,

                uint32_t           instanceCount,

                uint32_t           firstVertex,

                uint32_t           firstInstance,

                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexed( uint32_t           indexCount,

                       uint32_t           instanceCount,

                       uint32_t           firstIndex,

                       int32_t            vertexOffset,

                       uint32_t           firstInstance,

                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                        VULKAN_HPP_NAMESPACE::DeviceSize offset,

                        uint32_t                         drawCount,

                        uint32_t                         stride,

                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                               VULKAN_HPP_NAMESPACE::DeviceSize offset,

                               uint32_t                         drawCount,

                               uint32_t                         stride,

                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatch( uint32_t           groupCountX,

                    uint32_t           groupCountY,

                    uint32_t           groupCountZ,

                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                            VULKAN_HPP_NAMESPACE::DeviceSize offset,

                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,

                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,

                      uint32_t                                 regionCount,

                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,

                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                                                     srcBuffer,

                      VULKAN_HPP_NAMESPACE::Buffer                                                     dstBuffer,

                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,

                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,

                     VULKAN_HPP_NAMESPACE::Image             dstImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,

                     uint32_t                                regionCount,

                     const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,

                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,

                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,

                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,

                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,

                     VULKAN_HPP_NAMESPACE::Image             dstImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,

                     uint32_t                                regionCount,

                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,

                     VULKAN_HPP_NAMESPACE::Filter            filter,

                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,

                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,

                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,

                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,

                     VULKAN_HPP_NAMESPACE::Filter                                                    filter,

                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,

                             VULKAN_HPP_NAMESPACE::Image                   dstImage,

                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,

                             uint32_t                                      regionCount,

                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                                          srcBuffer,

                             VULKAN_HPP_NAMESPACE::Image                                                           dstImage,

                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     dstImageLayout,

                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,

                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,

                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,

                             uint32_t                                      regionCount,

                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                                           srcImage,

                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     srcImageLayout,

                             VULKAN_HPP_NAMESPACE::Buffer                                                          dstBuffer,

                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,

                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,

                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,

                        const void *                     pData,

                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer                             dstBuffer,

                        VULKAN_HPP_NAMESPACE::DeviceSize                         dstOffset,

                        VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data,

                        Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,

                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,

                      VULKAN_HPP_NAMESPACE::DeviceSize size,

                      uint32_t                         data,

                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,

                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,

                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,

                           uint32_t                                            rangeCount,

                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,

                           Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,

                           VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,

                           const VULKAN_HPP_NAMESPACE::ClearColorValue &                                               color,

                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,

                                  VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,

                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,

                                  uint32_t                                             rangeCount,

                                  const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,

                                  Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,

                                  VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,

                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                                        depthStencil,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearAttachments( uint32_t                                      attachmentCount,

                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,

                            uint32_t                                      rectCount,

                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,

                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,

                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,

                        VULKAN_HPP_NAMESPACE::Image                dstImage,

                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,

                        uint32_t                                   regionCount,

                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,

                        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                                        srcImage,

                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  srcImageLayout,

                        VULKAN_HPP_NAMESPACE::Image                                                        dstImage,

                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  dstImageLayout,

                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,

                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,

                    Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,

                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents( uint32_t                                          eventCount,

                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,

                      uint32_t                                          memoryBarrierCount,

                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,

                      uint32_t                                          bufferMemoryBarrierCount,

                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,

                      uint32_t                                          imageMemoryBarrierCount,

                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,

                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,

                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,

                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,

                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,

                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,

                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,

                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,

                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,

                           uint32_t                                          memoryBarrierCount,

                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,

                           uint32_t                                          bufferMemoryBarrierCount,

                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,

                           uint32_t                                          imageMemoryBarrierCount,

                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,

                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,

                           VULKAN_HPP_NAMESPACE::DependencyFlags                                                     dependencyFlags,

                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,

                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,

                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,

                      uint32_t                                query,

                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,

                      Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                    uint32_t                        query,

                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                          uint32_t                        firstQuery,

                          uint32_t                        queryCount,

                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,

                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,

                          uint32_t                                    query,

                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,

                                uint32_t                               firstQuery,

                                uint32_t                               queryCount,

                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,

                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,

                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,

                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,

                         uint32_t                               offset,

                         uint32_t                               size,

                         const void *                           pValues,

                         Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout                       layout,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlags                     stageFlags,

                         uint32_t                                                   offset,

                         VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values,

                         Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,

                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,

                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeCommands( uint32_t                                    commandBufferCount,

                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,

                           Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchBase( uint32_t           baseGroupX,

                        uint32_t           baseGroupY,

                        uint32_t           baseGroupZ,

                        uint32_t           groupCountX,

                        uint32_t           groupCountY,

                        uint32_t           groupCountZ,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_VERSION_1_2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                             VULKAN_HPP_NAMESPACE::DeviceSize offset,

                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                             uint32_t                         maxDrawCount,

                             uint32_t                         stride,

                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                    VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                    uint32_t                         maxDrawCount,

                                    uint32_t                         stride,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,

                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,

                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,

                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,

                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,

                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,

                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,

                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,

                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,

                     const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,

                     const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent2( VULKAN_HPP_NAMESPACE::Event               event,

                       VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,

                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents2( uint32_t                                     eventCount,

                       const VULKAN_HPP_NAMESPACE::Event *          pEvents,

                       const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,

                       Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,

                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,

                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,

                           VULKAN_HPP_NAMESPACE::QueryPool           queryPool,

                           uint32_t                                  query,

                           Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,

                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,

                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,

                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,

                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,

                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,

                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCount( uint32_t                               viewportCount,

                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,

                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCount( uint32_t                             scissorCount,

                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,

                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers2( uint32_t                                 firstBinding,

                              uint32_t                                 bindingCount,

                              const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,

                              const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                              const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,

                              const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,

                              Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers2(

       uint32_t                                                                                 firstBinding,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,

                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,

                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,

                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,

                                    Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,

                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                        VULKAN_HPP_NAMESPACE::StencilOp        failOp,

                        VULKAN_HPP_NAMESPACE::StencilOp        passOp,

                        VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,

                        VULKAN_HPP_NAMESPACE::CompareOp        compareOp,

                        Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,

                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,

                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,

                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_debug_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,

                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,

                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,

                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,

                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_decode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_transform_feedback ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,

                                           uint32_t                                 bindingCount,

                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,

                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,

                                           Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindTransformFeedbackBuffersEXT( uint32_t                                                                         firstBinding,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes

                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,

                                     uint32_t                                 counterBufferCount,

                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,

                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,

                                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,

                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,

                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets

                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,

                                   uint32_t                                 counterBufferCount,

                                   const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,

                                   const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,

                                   Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,

                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,

                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets

                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,

                                uint32_t                                query,

                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,

                                uint32_t                                index,

                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                              uint32_t                        query,

                              uint32_t                        index,

                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectByteCountEXT( uint32_t                         instanceCount,

                                    uint32_t                         firstInstance,

                                    VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,

                                    uint32_t                         counterOffset,

                                    uint32_t                         vertexStride,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NVX_binary_import ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,

                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_draw_indirect_count ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                uint32_t                         maxDrawCount,

                                uint32_t                         stride,

                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                       uint32_t                         maxDrawCount,

                                       uint32_t                         stride,

                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_dynamic_rendering ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_device_group ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchBaseKHR( uint32_t           baseGroupX,

                           uint32_t           baseGroupY,

                           uint32_t           baseGroupZ,

                           uint32_t           groupCountX,

                           uint32_t           groupCountY,

                           uint32_t           groupCountZ,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_push_descriptor ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,

                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,

                                uint32_t                                         set,

                                uint32_t                                         descriptorWriteCount,

                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,

                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,

                                VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,

                                uint32_t                                                                                 set,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,

                                            uint32_t                                       set,

                                            const void *                                   pData,

                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,

                                            uint32_t                                       set,

                                            DataType const &                               data,

                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_conditional_rendering ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_clip_space_w_scaling ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingNV( uint32_t                                         firstViewport,

                                 uint32_t                                         viewportCount,

                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,

                                 Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingNV( uint32_t                                                                                 firstViewport,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_discard_rectangles ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,

                                  uint32_t                             discardRectangleCount,

                                  const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDiscardRectangleEXT( uint32_t                                                                     firstDiscardRectangle,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,

                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,

                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_create_renderpass2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,

                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,

                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,

                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,

                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,

                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,

                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,

                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,

                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_AMDX_shader_enqueue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,

                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,

                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,

                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,

                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,

                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,

                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,

                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,

                                          VULKAN_HPP_NAMESPACE::DeviceAddress countInfo,

                                          Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_EXT_sample_locations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_acceleration_structure ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresKHR( uint32_t                                                                     infoCount,

                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,

                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresIndirectKHR( uint32_t                                                                infoCount,

                                                  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,

                                                  const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,

                                                  const uint32_t *                                                        pIndirectStrides,

                                                  const uint32_t * const *                                                ppMaxPrimitiveCounts,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructuresIndirectKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                                                        indirectStrides,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,

                                                    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,

                                                    VULKAN_HPP_NAMESPACE::QueryType                        queryType,

                                                    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,

                                                    uint32_t                                               firstQuery,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       VULKAN_HPP_NAMESPACE::QueryPool                                                                queryPool,

       uint32_t                                                                                       firstQuery,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_pipeline ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,

                        uint32_t                                                    width,

                        uint32_t                                                    height,

                        uint32_t                                                    depth,

                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,

                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,

                        uint32_t                                                    width,

                        uint32_t                                                    height,

                        uint32_t                                                    depth,

                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,

                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,

                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,

                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,

                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,

                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_shading_rate_image ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,

                                  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,

                                  Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,

                                           uint32_t                                           viewportCount,

                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportShadingRatePaletteNV( uint32_t                                                                                   firstViewport,

                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,

                                  uint32_t                                                customSampleOrderCount,

                                  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,

                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                                                   sampleOrderType,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_ray_tracing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,

                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,

                                        VULKAN_HPP_NAMESPACE::Bool32                              update,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,

                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,

                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,

                                        VULKAN_HPP_NAMESPACE::Bool32                              update,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,

                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,

                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,

                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,

                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,

                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,

                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,

                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,

                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,

                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,

                       uint32_t                         width,

                       uint32_t                         height,

                       uint32_t                         depth,

                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesNV( uint32_t                                              accelerationStructureCount,

                                                   const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,

                                                   VULKAN_HPP_NAMESPACE::QueryType                       queryType,

                                                   VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,

                                                   uint32_t                                              firstQuery,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeAccelerationStructuresPropertiesNV(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                               queryType,

       VULKAN_HPP_NAMESPACE::QueryPool                                                               queryPool,

       uint32_t                                                                                      firstQuery,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_draw_indirect_count ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                uint32_t                         maxDrawCount,

                                uint32_t                         stride,

                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                       uint32_t                         maxDrawCount,

                                       uint32_t                         stride,

                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_AMD_buffer_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,

                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,

                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,

                                uint32_t                                    marker,

                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_mesh_shader ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                   uint32_t                         drawCount,

                                   uint32_t                         stride,

                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                        uint32_t                         maxDrawCount,

                                        uint32_t                         stride,

                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_scissor_exclusive ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorEnableNV( uint32_t                             firstExclusiveScissor,

                                       uint32_t                             exclusiveScissorCount,

                                       const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,

                                       Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorEnableNV( uint32_t                                                                     firstExclusiveScissor,

                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,

                                 uint32_t                             exclusiveScissorCount,

                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,

                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExclusiveScissorNV( uint32_t                                                                     firstExclusiveScissor,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_diagnostic_checkpoints ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,

                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,

                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,

                                        Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,

                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_fragment_shading_rate ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,

                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,

                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_line_rasterization ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineStippleEXT( uint32_t           lineStippleFactor,

                             uint16_t           lineStipplePattern,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,

                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCountEXT( uint32_t                               viewportCount,

                                   const VULKAN_HPP_NAMESPACE::Viewport * pViewports,

                                   Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCountEXT( uint32_t                             scissorCount,

                                  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,

                                 uint32_t                                 bindingCount,

                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,

                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,

                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,

                                 Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindVertexBuffers2EXT(

       uint32_t                                                                                 firstBinding,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,

                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,

                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,

                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,

                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,

                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,

                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,

                           Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_device_generated_commands ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,

                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,

                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,

                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,

                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,

                                     uint32_t                                groupIndex,

                                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_depth_bias_control ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo,

                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo,

                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_encode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,

                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_NV_cuda_kernel_launch ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo,

                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo,

                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_KHR_synchronization2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,

                        const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,

                        const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event               event,

                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,

                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents2KHR( uint32_t                                     eventCount,

                          const VULKAN_HPP_NAMESPACE::Event *          pEvents,

                          const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,

                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,

                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,

                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,

                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,

                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,

                              VULKAN_HPP_NAMESPACE::QueryPool           queryPool,

                              uint32_t                                  query,

                              Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,

                                 VULKAN_HPP_NAMESPACE::Buffer              dstBuffer,

                                 VULKAN_HPP_NAMESPACE::DeviceSize          dstOffset,

                                 uint32_t                                  marker,

                                 Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_descriptor_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBuffersEXT( uint32_t                                                     bufferCount,

                                    const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint  pipelineBindPoint,

                                         VULKAN_HPP_NAMESPACE::PipelineLayout     layout,

                                         uint32_t                                 firstSet,

                                         uint32_t                                 setCount,

                                         const uint32_t *                         pBufferIndices,

                                         const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                          pipelineBindPoint,

                                         VULKAN_HPP_NAMESPACE::PipelineLayout                                             layout,

                                         uint32_t                                                                         firstSet,

                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                         bufferIndices,

                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                                                   VULKAN_HPP_NAMESPACE::PipelineLayout    layout,

                                                   uint32_t                                set,

                                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_fragment_shading_rate_enums ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,

                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_mesh_shader ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksEXT( uint32_t           groupCountX,

                            uint32_t           groupCountY,

                            uint32_t           groupCountZ,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                    uint32_t                         drawCount,

                                    uint32_t                         stride,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,

                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,

                                         uint32_t                         maxDrawCount,

                                         uint32_t                         stride,

                                         Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_copy_commands2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,

                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,

                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,

                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,

                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,

                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,

                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_vertex_input_dynamic_state ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setVertexInputEXT( uint32_t                                                          vertexBindingDescriptionCount,

                             const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,

                             uint32_t                                                          vertexAttributeDescriptionCount,

                             const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void

       setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,

                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,

                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_HUAWEI_subpass_shading ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_HUAWEI_invocation_mask ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,

                                    VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,

                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,

                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,

                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_color_write_enable ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteEnableEXT( uint32_t                             attachmentCount,

                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_maintenance1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,

                                 Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_multi_draw ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiEXT( uint32_t                                       drawCount,

                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,

                        uint32_t                                       instanceCount,

                        uint32_t                                       firstInstance,

                        uint32_t                                       stride,

                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,

                        uint32_t                                                                                      instanceCount,

                        uint32_t                                                                                      firstInstance,

                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiIndexedEXT( uint32_t                                              drawCount,

                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,

                               uint32_t                                              instanceCount,

                               uint32_t                                              firstInstance,

                               uint32_t                                              stride,

                               const int32_t *                                       pVertexOffset,

                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,

                               uint32_t                                                                                             instanceCount,

                               uint32_t                                                                                             firstInstance,

                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_opacity_micromap ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildMicromapsEXT( uint32_t                                           infoCount,

                             const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,

                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,

                                       const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,

                                       VULKAN_HPP_NAMESPACE::QueryType           queryType,

                                       VULKAN_HPP_NAMESPACE::QueryPool           queryPool,

                                       uint32_t                                  firstQuery,

                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                       VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                       VULKAN_HPP_NAMESPACE::QueryPool                                                   queryPool,

                                       uint32_t                                                                          firstQuery,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_HUAWEI_cluster_culling_shader ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawClusterHUAWEI( uint32_t           groupCountX,

                             uint32_t           groupCountY,

                             uint32_t           groupCountZ,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,

                                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_copy_memory_indirect ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,

                                uint32_t                            copyCount,

                                uint32_t                            stride,

                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                  copyBufferAddress,

                                       uint32_t                                             copyCount,

                                       uint32_t                                             stride,

                                       VULKAN_HPP_NAMESPACE::Image                          dstImage,

                                       VULKAN_HPP_NAMESPACE::ImageLayout                    dstImageLayout,

                                       const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,

                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                                                          copyBufferAddress,

                                       uint32_t                                                                                     stride,

                                       VULKAN_HPP_NAMESPACE::Image                                                                  dstImage,

                                       VULKAN_HPP_NAMESPACE::ImageLayout                                                            dstImageLayout,

                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_memory_decompression ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryNV( uint32_t                                               decompressRegionCount,

                              const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,

                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,

                                           VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,

                                           uint32_t                            stride,

                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_device_generated_commands_compute ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,

                                          VULKAN_HPP_NAMESPACE::Pipeline          pipeline,

                                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_extended_dynamic_state3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,

                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode,

                             Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples,

                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                            const VULKAN_HPP_NAMESPACE::SampleMask *  pSampleMask,

                            Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits                                        samples,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable,

                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable,

                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEnableEXT( uint32_t                             firstAttachment,

                                  uint32_t                             attachmentCount,

                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,

                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEnableEXT( uint32_t                                                                     firstAttachment,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEquationEXT( uint32_t                                            firstAttachment,

                                    uint32_t                                            attachmentCount,

                                    const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,

                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendEquationEXT( uint32_t                                                                                    firstAttachment,

                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteMaskEXT( uint32_t                                          firstAttachment,

                                uint32_t                                          attachmentCount,

                                const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorWriteMaskEXT( uint32_t                                                                                  firstAttachment,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setExtraPrimitiveOverestimationSizeEXT( float              extraPrimitiveOverestimationSize,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable,

                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendAdvancedEXT( uint32_t                                            firstAttachment,

                                    uint32_t                                            attachmentCount,

                                    const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,

                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setColorBlendAdvancedEXT( uint32_t                                                                                    firstAttachment,

                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode,

                                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode,

                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,

                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne,

                                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportSwizzleNV( uint32_t                                        firstViewport,

                                uint32_t                                        viewportCount,

                                const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,

                                Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setViewportSwizzleNV( uint32_t                                                                                firstViewport,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,

                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageToColorLocationNV( uint32_t           coverageToColorLocation,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode,

                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,

                                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableNV( uint32_t           coverageModulationTableCount,

                                        const float *      pCoverageModulationTable,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,

                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,

                                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode,

                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,

                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_maintenance5 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,

                               VULKAN_HPP_NAMESPACE::DeviceSize offset,

                               VULKAN_HPP_NAMESPACE::DeviceSize size,

                               VULKAN_HPP_NAMESPACE::IndexType  indexType,

                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_shader_object ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindShadersEXT( uint32_t                                          stageCount,

                          const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages,

                          const VULKAN_HPP_NAMESPACE::ShaderEXT *           pShaders,

                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,

                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const &           shaders,

                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_attachment_feedback_loop_dynamic_state ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask,

                                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_maintenance6 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo,

                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo,

                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR * pPushConstantsInfo,

                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo,

                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR * pPushDescriptorSetInfo,

                                 Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo,

                                 Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBufferEmbeddedSamplers2EXT(

       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,

       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void bindDescriptorBufferEmbeddedSamplers2EXT(

       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,

       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandBuffer == VK_NULL_HANDLE;

     }


   private:

     VkCommandBuffer m_commandBuffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DeviceMemory

   {

   public:

     using CType      = VkDeviceMemory;

     using NativeType = VkDeviceMemory;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;


   public:

     VULKAN_HPP_CONSTEXPR DeviceMemory() = default;


     VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT

     {

       m_deviceMemory = deviceMemory;

       return *this;

     }

 #endif


     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_deviceMemory = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DeviceMemory const & ) const = default;

 #else

     bool                                 operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory == rhs.m_deviceMemory;

     }


     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory != rhs.m_deviceMemory;

     }


     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory < rhs.m_deviceMemory;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_deviceMemory == VK_NULL_HANDLE;

     }


   private:

     VkDeviceMemory m_deviceMemory = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class VideoSessionKHR

   {

   public:

     using CType      = VkVideoSessionKHR;

     using NativeType = VkVideoSessionKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;


     VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionKHR = videoSessionKHR;

       return *this;

     }

 #endif


     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( VideoSessionKHR const & ) const = default;

 #else

     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR == rhs.m_videoSessionKHR;

     }


     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR != rhs.m_videoSessionKHR;

     }


     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR < rhs.m_videoSessionKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionKHR == VK_NULL_HANDLE;

     }


   private:

     VkVideoSessionKHR m_videoSessionKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DeferredOperationKHR

   {

   public:

     using CType      = VkDeferredOperationKHR;

     using NativeType = VkDeferredOperationKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default;


     VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT

       : m_deferredOperationKHR( deferredOperationKHR )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_deferredOperationKHR = deferredOperationKHR;

       return *this;

     }

 #endif


     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_deferredOperationKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DeferredOperationKHR const & ) const = default;

 #else

     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;

     }


     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;

     }


     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_deferredOperationKHR == VK_NULL_HANDLE;

     }


   private:

     VkDeferredOperationKHR m_deferredOperationKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #if defined( VK_USE_PLATFORM_FUCHSIA )

   class BufferCollectionFUCHSIA

   {

   public:

     using CType      = VkBufferCollectionFUCHSIA;

     using NativeType = VkBufferCollectionFUCHSIA;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;


   public:

     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;


     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT

       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )

     {

     }


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;

       return *this;

     }

 #  endif


     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferCollectionFUCHSIA = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;

 #  else

     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;

     }


     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;

     }


     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;

     }


   private:

     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_USE_PLATFORM_FUCHSIA*/


   class BufferView

   {

   public:

     using CType      = VkBufferView;

     using NativeType = VkBufferView;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;


   public:

     VULKAN_HPP_CONSTEXPR BufferView() = default;


     VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferView = bufferView;

       return *this;

     }

 #endif


     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_bufferView = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( BufferView const & ) const = default;

 #else

     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView == rhs.m_bufferView;

     }


     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView != rhs.m_bufferView;

     }


     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView < rhs.m_bufferView;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_bufferView == VK_NULL_HANDLE;

     }


   private:

     VkBufferView m_bufferView = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferView;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>

   {

     using Type = VULKAN_HPP_NAMESPACE::BufferView;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CommandPool

   {

   public:

     using CType      = VkCommandPool;

     using NativeType = VkCommandPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;


   public:

     VULKAN_HPP_CONSTEXPR CommandPool() = default;


     VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT

     {

       m_commandPool = commandPool;

       return *this;

     }

 #endif


     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_commandPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CommandPool const & ) const = default;

 #else

     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool == rhs.m_commandPool;

     }


     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool != rhs.m_commandPool;

     }


     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool < rhs.m_commandPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_commandPool == VK_NULL_HANDLE;

     }


   private:

     VkCommandPool m_commandPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::CommandPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PipelineCache

   {

   public:

     using CType      = VkPipelineCache;

     using NativeType = VkPipelineCache;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;


   public:

     VULKAN_HPP_CONSTEXPR PipelineCache() = default;


     VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineCache = pipelineCache;

       return *this;

     }

 #endif


     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_pipelineCache = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PipelineCache const & ) const = default;

 #else

     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache == rhs.m_pipelineCache;

     }


     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache != rhs.m_pipelineCache;

     }


     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache < rhs.m_pipelineCache;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_pipelineCache == VK_NULL_HANDLE;

     }


   private:

     VkPipelineCache m_pipelineCache = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>

   {

     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CuFunctionNVX

   {

   public:

     using CType      = VkCuFunctionNVX;

     using NativeType = VkCuFunctionNVX;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;


   public:

     VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;


     VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT

     {

       m_cuFunctionNVX = cuFunctionNVX;

       return *this;

     }

 #endif


     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cuFunctionNVX = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CuFunctionNVX const & ) const = default;

 #else

     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;

     }


     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;

     }


     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuFunctionNVX == VK_NULL_HANDLE;

     }


   private:

     VkCuFunctionNVX m_cuFunctionNVX = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class CuModuleNVX

   {

   public:

     using CType      = VkCuModuleNVX;

     using NativeType = VkCuModuleNVX;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;


   public:

     VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;


     VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT

     {

       m_cuModuleNVX = cuModuleNVX;

       return *this;

     }

 #endif


     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cuModuleNVX = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CuModuleNVX const & ) const = default;

 #else

     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX == rhs.m_cuModuleNVX;

     }


     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX != rhs.m_cuModuleNVX;

     }


     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX < rhs.m_cuModuleNVX;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cuModuleNVX == VK_NULL_HANDLE;

     }


   private:

     VkCuModuleNVX m_cuModuleNVX = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>

   {

     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   class CudaFunctionNV

   {

   public:

     using CType      = VkCudaFunctionNV;

     using NativeType = VkCudaFunctionNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;


   public:

     VULKAN_HPP_CONSTEXPR CudaFunctionNV() = default;


     VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT

     {

       m_cudaFunctionNV = cudaFunctionNV;

       return *this;

     }

 #  endif


     CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cudaFunctionNV = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CudaFunctionNV const & ) const = default;

 #  else

     bool operator==( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV == rhs.m_cudaFunctionNV;

     }


     bool operator!=( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV != rhs.m_cudaFunctionNV;

     }


     bool operator<( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV < rhs.m_cudaFunctionNV;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaFunctionNV == VK_NULL_HANDLE;

     }


   private:

     VkCudaFunctionNV m_cudaFunctionNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

   class CudaModuleNV

   {

   public:

     using CType      = VkCudaModuleNV;

     using NativeType = VkCudaModuleNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;


   public:

     VULKAN_HPP_CONSTEXPR CudaModuleNV() = default;


     VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}


 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT

     {

       m_cudaModuleNV = cudaModuleNV;

       return *this;

     }

 #  endif


     CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_cudaModuleNV = {};

       return *this;

     }


 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( CudaModuleNV const & ) const = default;

 #  else

     bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV == rhs.m_cudaModuleNV;

     }


     bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV != rhs.m_cudaModuleNV;

     }


     bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV < rhs.m_cudaModuleNV;

     }

 #  endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_cudaModuleNV == VK_NULL_HANDLE;

     }


   private:

     VkCudaModuleNV m_cudaModuleNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };

 #endif /*VK_ENABLE_BETA_EXTENSIONS*/


   class DescriptorPool

   {

   public:

     using CType      = VkDescriptorPool;

     using NativeType = VkDescriptorPool;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;


   public:

     VULKAN_HPP_CONSTEXPR DescriptorPool() = default;


     VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorPool = descriptorPool;

       return *this;

     }

 #endif


     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorPool = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorPool const & ) const = default;

 #else

     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool == rhs.m_descriptorPool;

     }


     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool != rhs.m_descriptorPool;

     }


     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool < rhs.m_descriptorPool;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorPool == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorPool m_descriptorPool = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DescriptorSetLayout

   {

   public:

     using CType      = VkDescriptorSetLayout;

     using NativeType = VkDescriptorSetLayout;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;


   public:

     VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;


     VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT

       : m_descriptorSetLayout( descriptorSetLayout )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSetLayout = descriptorSetLayout;

       return *this;

     }

 #endif


     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_descriptorSetLayout = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DescriptorSetLayout const & ) const = default;

 #else

     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;

     }


     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;

     }


     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_descriptorSetLayout == VK_NULL_HANDLE;

     }


   private:

     VkDescriptorSetLayout m_descriptorSetLayout = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>

   {

     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Framebuffer

   {

   public:

     using CType      = VkFramebuffer;

     using NativeType = VkFramebuffer;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;


   public:

     VULKAN_HPP_CONSTEXPR Framebuffer() = default;


     VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT

     {

       m_framebuffer = framebuffer;

       return *this;

     }

 #endif


     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_framebuffer = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Framebuffer const & ) const = default;

 #else

     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer == rhs.m_framebuffer;

     }


     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer != rhs.m_framebuffer;

     }


     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer < rhs.m_framebuffer;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_framebuffer == VK_NULL_HANDLE;

     }


   private:

     VkFramebuffer m_framebuffer = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>

   {

     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class IndirectCommandsLayoutNV

   {

   public:

     using CType      = VkIndirectCommandsLayoutNV;

     using NativeType = VkIndirectCommandsLayoutNV;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;


     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT

       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT

     {

       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;

       return *this;

     }

 #endif


     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_indirectCommandsLayoutNV = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;

 #else

     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;

     }


     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;

     }


     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;

     }


   private:

     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>

   {

     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PrivateDataSlot

   {

   public:

     using CType      = VkPrivateDataSlot;

     using NativeType = VkPrivateDataSlot;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR PrivateDataSlot() = default;


     VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT

     {

       m_privateDataSlot = privateDataSlot;

       return *this;

     }

 #endif


     PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_privateDataSlot = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PrivateDataSlot const & ) const = default;

 #else

     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot == rhs.m_privateDataSlot;

     }


     bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot != rhs.m_privateDataSlot;

     }


     bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot < rhs.m_privateDataSlot;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_privateDataSlot == VK_NULL_HANDLE;

     }


   private:

     VkPrivateDataSlot m_privateDataSlot = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>

   {

     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   using PrivateDataSlotEXT = PrivateDataSlot;


   class RenderPass

   {

   public:

     using CType      = VkRenderPass;

     using NativeType = VkRenderPass;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;


   public:

     VULKAN_HPP_CONSTEXPR RenderPass() = default;


     VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT

     {

       m_renderPass = renderPass;

       return *this;

     }

 #endif


     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_renderPass = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( RenderPass const & ) const = default;

 #else

     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass == rhs.m_renderPass;

     }


     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass != rhs.m_renderPass;

     }


     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass < rhs.m_renderPass;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_renderPass == VK_NULL_HANDLE;

     }


   private:

     VkRenderPass m_renderPass = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>

   {

     using Type = VULKAN_HPP_NAMESPACE::RenderPass;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>

   {

     using Type = VULKAN_HPP_NAMESPACE::RenderPass;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Sampler

   {

   public:

     using CType      = VkSampler;

     using NativeType = VkSampler;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;


   public:

     VULKAN_HPP_CONSTEXPR Sampler() = default;


     VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT

     {

       m_sampler = sampler;

       return *this;

     }

 #endif


     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_sampler = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Sampler const & ) const = default;

 #else

     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler == rhs.m_sampler;

     }


     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler != rhs.m_sampler;

     }


     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler < rhs.m_sampler;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_sampler == VK_NULL_HANDLE;

     }


   private:

     VkSampler m_sampler = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>

   {

     using Type = VULKAN_HPP_NAMESPACE::Sampler;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>

   {

     using Type = VULKAN_HPP_NAMESPACE::Sampler;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class SamplerYcbcrConversion

   {

   public:

     using CType      = VkSamplerYcbcrConversion;

     using NativeType = VkSamplerYcbcrConversion;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;


   public:

     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;


     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT

       : m_samplerYcbcrConversion( samplerYcbcrConversion )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT

     {

       m_samplerYcbcrConversion = samplerYcbcrConversion;

       return *this;

     }

 #endif


     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_samplerYcbcrConversion = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( SamplerYcbcrConversion const & ) const = default;

 #else

     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;

     }


     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;

     }


     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_samplerYcbcrConversion == VK_NULL_HANDLE;

     }


   private:

     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>

   {

     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>

   {

     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;


   class ShaderModule

   {

   public:

     using CType      = VkShaderModule;

     using NativeType = VkShaderModule;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;


   public:

     VULKAN_HPP_CONSTEXPR ShaderModule() = default;


     VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderModule = shaderModule;

       return *this;

     }

 #endif


     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_shaderModule = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ShaderModule const & ) const = default;

 #else

     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule == rhs.m_shaderModule;

     }


     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule != rhs.m_shaderModule;

     }


     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule < rhs.m_shaderModule;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_shaderModule == VK_NULL_HANDLE;

     }


   private:

     VkShaderModule m_shaderModule = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>

   {

     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>

   {

     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class ValidationCacheEXT

   {

   public:

     using CType      = VkValidationCacheEXT;

     using NativeType = VkValidationCacheEXT;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;


   public:

     VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default;


     VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT

     {

       m_validationCacheEXT = validationCacheEXT;

       return *this;

     }

 #endif


     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_validationCacheEXT = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( ValidationCacheEXT const & ) const = default;

 #else

     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT == rhs.m_validationCacheEXT;

     }


     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT != rhs.m_validationCacheEXT;

     }


     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT < rhs.m_validationCacheEXT;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_validationCacheEXT == VK_NULL_HANDLE;

     }


   private:

     VkValidationCacheEXT m_validationCacheEXT = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>

   {

     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class VideoSessionParametersKHR

   {

   public:

     using CType      = VkVideoSessionParametersKHR;

     using NativeType = VkVideoSessionParametersKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


   public:

     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;


     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT

       : m_videoSessionParametersKHR( videoSessionParametersKHR )

     {

     }


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionParametersKHR = videoSessionParametersKHR;

       return *this;

     }

 #endif


     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_videoSessionParametersKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( VideoSessionParametersKHR const & ) const = default;

 #else

     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;

     }


     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;

     }


     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_videoSessionParametersKHR == VK_NULL_HANDLE;

     }


   private:

     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Queue

   {

   public:

     using CType      = VkQueue;

     using NativeType = VkQueue;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;


   public:

     VULKAN_HPP_CONSTEXPR Queue() = default;


     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}


     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT

     {

       m_queue = queue;

       return *this;

     }


     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_queue = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Queue const & ) const = default;

 #else

     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue == rhs.m_queue;

     }


     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue != rhs.m_queue;

     }


     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_queue < rhs.m_queue;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result submit( uint32_t                                 submitCount,

                                         const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,

                                         VULKAN_HPP_NAMESPACE::Fence              fence,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,

               VULKAN_HPP_NAMESPACE::Fence fence                                                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

               Dispatch const & d                                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindSparse( uint32_t                                     bindInfoCount,

                                             const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,

                                             VULKAN_HPP_NAMESPACE::Fence                  fence,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,

                   VULKAN_HPP_NAMESPACE::Fence fence                                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                   Dispatch const & d                                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result submit2( uint32_t                                  submitCount,

                                          const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,

                                          VULKAN_HPP_NAMESPACE::Fence               fence,

                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,

                VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,

                                                                   Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,

                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_diagnostic_checkpoints ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,

                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,

                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,

               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>

                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,

       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>

       getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                            Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_synchronization2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t                                  submitCount,

                                             const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,

                                             VULKAN_HPP_NAMESPACE::Fence               fence,

                                             Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,

                   VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                   Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,

                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,

                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,

               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>

                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,

       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>

       getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_low_latency2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,

                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,

                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkQueue() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_queue == VK_NULL_HANDLE;

     }


   private:

     VkQueue m_queue = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>

   {

     using Type = VULKAN_HPP_NAMESPACE::Queue;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>

   {

     using Type = VULKAN_HPP_NAMESPACE::Queue;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Device

   {

   public:

     using CType      = VkDevice;

     using NativeType = VkDevice;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;


   public:

     VULKAN_HPP_CONSTEXPR Device() = default;


     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}


     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT

     {

       m_device = device;

       return *this;

     }


     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_device = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Device const & ) const = default;

 #else

     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device == rhs.m_device;

     }


     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device != rhs.m_device;

     }


     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_device < rhs.m_device;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueue( uint32_t                      queueFamilyIndex,

                    uint32_t                      queueIndex,

                    VULKAN_HPP_NAMESPACE::Queue * pQueue,

                    Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue

       getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,

                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                 VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type

       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,

                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type

       allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,

                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                                  memory,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,

                                            VULKAN_HPP_NAMESPACE::DeviceSize     offset,

                                            VULKAN_HPP_NAMESPACE::DeviceSize     size,

                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,

                                            void **                              ppData,

                                            Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,

                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           offset,

                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           size,

                                                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,

                                                          const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,

                                                               const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,

                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize

       getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,

                                                   VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                                                   VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,

                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,

                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,

                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,

                                                  VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                                                  VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,

                                                  Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,

                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,

                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,

                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,

                                       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements

       getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,

                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,

                                      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements

       getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                           image,

                                            uint32_t *                                            pSparseMemoryRequirementCount,

                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>

       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>

                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,

                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,

                                                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,

                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type

       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,

                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type

       createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,

                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Fence                                         fence,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result resetFences( uint32_t                            fenceCount,

                                              const VULKAN_HPP_NAMESPACE::Fence * pFences,

                                              Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,

                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,

                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitForFences( uint32_t                            fenceCount,

                                                const VULKAN_HPP_NAMESPACE::Fence * pFences,

                                                VULKAN_HPP_NAMESPACE::Bool32        waitAll,

                                                uint64_t                            timeout,

                                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,

                                                                      VULKAN_HPP_NAMESPACE::Bool32                                                waitAll,

                                                                      uint64_t                                                                    timeout,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,

                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                  VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type

       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type

       createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,

                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                                     semaphore,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,

                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                              VULKAN_HPP_NAMESPACE::Event *                     pEvent,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type

       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,

                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type

       createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,

                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Event                                         event,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,

                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,

                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,

                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event,

                                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,

                                             Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,

                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                  VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type

       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type

       createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,

                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                                     queryPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,

                                                      uint32_t                               firstQuery,

                                                      uint32_t                               queryCount,

                                                      size_t                                 dataSize,

                                                      void *                                 pData,

                                                      VULKAN_HPP_NAMESPACE::DeviceSize       stride,

                                                      VULKAN_HPP_NAMESPACE::QueryResultFlags flags,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>

                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,

                                               uint32_t                                     firstQuery,

                                               uint32_t                                     queryCount,

                                               size_t                                       dataSize,

                                               VULKAN_HPP_NAMESPACE::DeviceSize             stride,

                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,

                                                                    uint32_t                                     firstQuery,

                                                                    uint32_t                                     queryCount,

                                                                    VULKAN_HPP_NAMESPACE::DeviceSize             stride,

                                                                    VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,

                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                               VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type

       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,

                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type

       createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,

                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Buffer                                        buffer,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,

                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,

                                                   VULKAN_HPP_NAMESPACE::BufferView *                 pView,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type

       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type

       createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,

                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferView                                    bufferView,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,

                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                              VULKAN_HPP_NAMESPACE::Image *                     pImage,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type

       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,

                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type

       createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,

                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyImage( VULKAN_HPP_NAMESPACE::Image image                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Image                                         image,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,

                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,

                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,

                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout

                          getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,

                                                     const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,

                                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,

                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                  VULKAN_HPP_NAMESPACE::ImageView *                 pView,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type

       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type

       createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,

                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ImageView                                     imageView,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,

                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,

                                                     VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type

       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type

       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule                     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                                  shaderModule,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type

       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type

       createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,

                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                                                       size_t *                            pDataSize,

                                                       void *                              pData,

                                                       Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                             Uint8_tAllocator &                  uint8_tAllocator,

                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,

                                                      uint32_t                                    srcCacheCount,

                                                      const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                                                 dstCache,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,

                            Dispatch const & d                                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,

                                                          uint32_t                                                 createInfoCount,

                                                          const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,

                                                          VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,

                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,

                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,

               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,

                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,

                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,

                                                   PipelineAllocator &                                                                              pipelineAllocator,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,

                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,

                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,

                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,

                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,

                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,

                                                         PipelineAllocator &                                                                              pipelineAllocator,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                        const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,

                                                         uint32_t                                                createInfoCount,

                                                         const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,

                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                         VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,

                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,

                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,

               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,

                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,

                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,

                                                  PipelineAllocator &                                                                             pipelineAllocator,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                 const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,

                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,

                                                        PipelineAllocator &                                                                             pipelineAllocator,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,

                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                                      pipeline,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type

       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type

       createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,

                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout                                pipelineLayout,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,

                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type

       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,

                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type

       createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,

                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler                               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Sampler                                       sampler,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,

                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,

                                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type

       createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type

       createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,

                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout                           descriptorSetLayout,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type

       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type

       createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,

                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool                                descriptorPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,

                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,

                               VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                               Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,

                                                         VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type

       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,

                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,

               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type

       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,

                               DescriptorSetAllocator &                                descriptorSetAllocator,

                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type

       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,

                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,

       typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,

                               int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type

       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,

                                     DescriptorSetAllocator &                                descriptorSetAllocator,

                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,

                                uint32_t                                    descriptorSetCount,

                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,

                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,

                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result( free )( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,

                     uint32_t                                    descriptorSetCount,

                     const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,

                     Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,

                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,

                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,

                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,

                                uint32_t                                         descriptorCopyCount,

                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,

                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,

                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type

       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type

       createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                                   framebuffer,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,

                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,

                                                   VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type

       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type

       createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,

                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                                    renderPass,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,

                                    VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,

                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D

                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,

                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type

       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type

       createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                                   commandPool,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,

                                                   VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,

                                                            VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,

                                                         VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type

       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,

                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,

               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type

       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,

                               CommandBufferAllocator &                                commandBufferAllocator,

                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type

       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,

                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename CommandBufferAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,

       typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,

                               int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type

       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,

                                     CommandBufferAllocator &                                commandBufferAllocator,

                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,

                              uint32_t                                    commandBufferCount,

                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,

                              Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,

                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,

                   uint32_t                                    commandBufferCount,

                   const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,

                   Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void( free )( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,

                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,

                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t                                           bindInfoCount,

                                                    const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,

                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t                                          bindInfoCount,

                                                   const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,

                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,

                                      uint32_t                                       localDeviceIndex,

                                      uint32_t                                       remoteDeviceIndex,

                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,

                                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags

                          getGroupPeerMemoryFeatures( uint32_t           heapIndex,

                                                      uint32_t           localDeviceIndex,

                                                      uint32_t           remoteDeviceIndex,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,

                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,

                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,

                                             uint32_t *                                                       pSparseMemoryRequirementCount,

                                             VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                             SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,

                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,

                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,

                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,

                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,

                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                               VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type

       createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type

       createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,

                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                        ycbcrConversion,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type

       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type

       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                      descriptorUpdateTemplate,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                           const void *                                   pData,

                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                           DataType const &                               data,

                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,

                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport

                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type

       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type

       createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                          uint32_t                        firstQuery,

                          uint32_t                        queryCount,

                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,

                                                           uint64_t *                      pValue,

                                                           Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,

                                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,

                                                 uint64_t                                        timeout,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,

                                                                       uint64_t                                        timeout,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type

       createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type

       createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,

                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot                               privateDataSlot,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                 uint64_t                              objectHandle,

                                                 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                 uint64_t                              data,

                                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                          uint64_t                              objectHandle,

                                                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                          uint64_t                              data,

                                                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                          uint64_t                              objectHandle,

                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                          uint64_t *                            pData,

                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                   uint64_t                              objectHandle,

                                                   VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                   Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,

                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                            uint32_t *                                                  pSparseMemoryRequirementCount,

                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                            SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,

                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,

                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,

                                                     VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type

       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type

       createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,

                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain                        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                                  swapchain,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                        uint32_t *                         pSwapchainImageCount,

                                                        VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,

                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type

       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,

               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR(

       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                      uint64_t                           timeout,

                                                      VULKAN_HPP_NAMESPACE::Semaphore    semaphore,

                                                      VULKAN_HPP_NAMESPACE::Fence        fence,

                                                      uint32_t *                         pImageIndex,

                                                      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,

                                                                     uint64_t                                  timeout,

                                                                     VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                                     VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                                                     Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type

       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,

                                                                 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type

       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,

                                                       uint32_t *                                            pImageIndex,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t                                             swapchainCount,

                                                            const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,

                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,

                                                            VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type

       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,

               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type

       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,

                                  SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type

       createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type

       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,

       typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,

                               int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type

       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,

                                        SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type

       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_debug_marker ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,

                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,

                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type

       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type

       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,

                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession                  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR                               videoSession,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                     videoSession,

                                                                       uint32_t *                                                pMemoryRequirementsCount,

                                                                       VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,

               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type

       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,

                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,

               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type

       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,

                                             VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,

                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                       videoSession,

                                                            uint32_t                                                    bindSessionMemoryInfoCount,

                                                            const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                                                               videoSession,

                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,

                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,

                                                                  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type

       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type

       createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,

                                                                  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,

                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,

                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,

                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                     videoSessionParameters,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NVX_binary_import ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type

       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type

       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type

       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type

       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,

                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NVX_image_view_handle ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,

                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,

                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,

                                                         VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type

       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_shader_info ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                                                   VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                                                   VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                                                   size_t *                                  pInfoSize,

                                                   void *                                    pInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,

                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,

                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,

                         Uint8_tAllocator &                        uint8_tAllocator,

                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_NV_external_memory_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,

                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,

                                                         HANDLE *                                              pHandle,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,

                                                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,

                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_device_group ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,

                                         uint32_t                                       localDeviceIndex,

                                         uint32_t                                       remoteDeviceIndex,

                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,

                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags

                          getGroupPeerMemoryFeaturesKHR( uint32_t           heapIndex,

                                                         uint32_t           localDeviceIndex,

                                                         uint32_t           remoteDeviceIndex,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_maintenance1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,

                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,

                              Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_memory_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                          HANDLE *                                                  pHandle,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,

                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                                                    HANDLE                                                 handle,

                                                                    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(

       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_memory_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,

                                                 int *                                            pFd,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,

                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                                           int                                                    fd,

                                                           VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR(

       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_semaphore_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,

                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                             HANDLE *                                                     pHandle,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,

                                   Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_semaphore_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,

                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,

                                                    int *                                               pFd,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,

                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_descriptor_update_template ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,

                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type

       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type

       createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,

                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator

                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,

                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                              const void *                                   pData,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,

                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,

                                              DataType const &                               data,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_display_control ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,

                                                         const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,

                                                                  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,

                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type

       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type

       registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,

                                                          const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                          VULKAN_HPP_NAMESPACE::Fence *                     pFence,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type

       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,

                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type

       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,

                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,

                                                         VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,

                                                         uint64_t *                                      pCounterValue,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,

                                                                                           VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,

                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_GOOGLE_display_timing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,

                                                                VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type

       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                                                                  uint32_t *                                           pPresentationTimingCount,

                                                                  VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type

       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type

       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,

                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,

                                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_hdr_metadata ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setHdrMetadataEXT( uint32_t                                     swapchainCount,

                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,

                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,

                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,

                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_create_renderpass2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                       VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type

       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type

       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_shared_presentable_image ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_external_fence_win32 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,

                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,

                                                         HANDLE *                                                 pHandle,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type

       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,

                               Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_external_fence_fd ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,

                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,

                                                int *                                           pFd,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,

                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,

                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,

                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,

                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

     //=== VK_ANDROID_external_memory_android_hardware_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer *                                 buffer,

                                                  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,

                                                                        struct AHardwareBuffer **                                               pBuffer,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type

       getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_AMDX_shader_enqueue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                pipelineCache,

                                                                    uint32_t                                                           createInfoCount,

                                                                    const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,

                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,

                                                                    VULKAN_HPP_NAMESPACE::Pipeline *                                   pPipelines,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,

               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,

                                                             PipelineAllocator & pipelineAllocator,

                                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                            const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,

                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createExecutionGraphPipelinesAMDXUnique(

                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createExecutionGraphPipelinesAMDXUnique(

                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,

                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,

                            PipelineAllocator &                                                                                        pipelineAllocator,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique(

       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

       const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,

       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                executionGraph,

                                                 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type

       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,

                                                 Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,

                                                                         const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,

                                                                         uint32_t *                                                          pNodeIndex,

                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type

       getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,

                                               const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


     //=== VK_KHR_get_memory_requirements2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,

                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,

                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,

                                                uint32_t *                                                       pSparseMemoryRequirementCount,

                                                VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,

                                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,

                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_acceleration_structure ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type

       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type

       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                      accelerationStructure,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,

                                                                 uint32_t                                                                     infoCount,

                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,

                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(

       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                                           deferredOperation,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,

                                                               const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,

                                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,

                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,

                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,

                                                 VULKAN_HPP_NAMESPACE::QueryType                        queryType,

                                                 size_t                                                 dataSize,

                                                 void *                                                 pData,

                                                 size_t                                                 stride,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       size_t                                                                                         dataSize,

       size_t                                                                                         stride,

       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR(

       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,

       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,

       size_t                                                                                         stride,

       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress

       getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,

                                                    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR

                          getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,

                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,

                                                 const uint32_t *                                                        pMaxPrimitiveCounts,

                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(

       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                     buildType,

       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &     buildInfo,

       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_ray_tracing_pipeline ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,

                                                               VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,

                                                               uint32_t                                                      createInfoCount,

                                                               const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,

                                                               VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,

                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,

               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,

                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,

                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,

                                                        PipelineAllocator &                                                                                   pipelineAllocator,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,

                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,

                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,

                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,

                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,

                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,

                                                              PipelineAllocator & pipelineAllocator,

                                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,

                                                             VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                             const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                                     uint32_t                       firstGroup,

                                                                     uint32_t                       groupCount,

                                                                     size_t                         dataSize,

                                                                     void *                         pData,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                           uint32_t                       firstGroup,

                                           uint32_t                       groupCount,

                                           size_t                         dataSize,

                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                        uint32_t                       firstGroup,

                                                        uint32_t                       groupCount,

                                                        size_t                         dataSize,

                                                        void *                         pData,

                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                        uint32_t                       firstGroup,

                                                        uint32_t                       groupCount,

                                                        size_t                         dataSize,

                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,

                                                      uint32_t                                   group,

                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_sampler_ycbcr_conversion ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,

                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                                  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type

       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type

       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,

                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,

                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_bind_memory2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t                                           bindInfoCount,

                                                       const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t                                          bindInfoCount,

                                                      const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_image_drm_format_modifier ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image                                 image,

                                                                         VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,

                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type

       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_validation_cache ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,

                                                           VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type

       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type

       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,

                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                            validationCache,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,

                                                           uint32_t                                         srcCacheCount,

                                                           const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                                 dstCache,

                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,

                                                            size_t *                                 pDataSize,

                                                            void *                                   pData,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,

                                  Uint8_tAllocator &                       uint8_tAllocator,

                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_ray_tracing ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type

       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type

       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,

                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV                       accelerationStructure,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,

                                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR

                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t                                                            bindInfoCount,

                                                                    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,

                                                              uint32_t                                                     createInfoCount,

                                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,

                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,

                                                              VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,

               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>

                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,

                                                       PipelineAllocator &                                                                                  pipelineAllocator,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>

                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,

                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,

               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>

                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,

                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,

                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,

                                                             PipelineAllocator &                                                                                  pipelineAllocator,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>

                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,

                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,

                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                                    uint32_t                       firstGroup,

                                                                    uint32_t                       groupCount,

                                                                    size_t                         dataSize,

                                                                    void *                         pData,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                          uint32_t                       firstGroup,

                                          uint32_t                       groupCount,

                                          size_t                         dataSize,

                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(

       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,

                                                                   size_t                                        dataSize,

                                                                   void *                                        pData,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(

       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,

                                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,

                                                    uint32_t                       shader,

                                                    Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_maintenance3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,

                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport

                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_external_memory_host ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                                                    const void *                                           pHostPointer,

                                                                    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type

       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                          const void *                                           pHostPointer,

                                          Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,

                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,

                                                             uint64_t *                                               pTimestamps,

                                                             uint64_t *                                               pMaxDeviation,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type

       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,

               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type

       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,

                                   Uint64_tAllocator &                                                                              uint64_tAllocator,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type

       getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,

                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_timeline_semaphore ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,

                                                              uint64_t *                      pValue,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type

       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,

                                                    uint64_t                                        timeout,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,

                                                                          uint64_t                                        timeout,

                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_INTEL_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,

                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,

                                                                       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type

       acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type

       acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                             Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,

                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,

                                                               VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type

       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,

                                     Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_AMD_display_native_hdr ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,

                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,

                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_EXT_buffer_device_address ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_present_wait ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                    uint64_t                           presentId,

                                                    uint64_t                           timeout,

                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                          uint64_t                           presentId,

                                                                          uint64_t                           timeout,

                                                                          Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_EXT_full_screen_exclusive ===


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                                  VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type

       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_buffer_device_address ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_host_query_reset ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,

                             uint32_t                        firstQuery,

                             uint32_t                        queryCount,

                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_deferred_host_operations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                             VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type

       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type

       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,

                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          operation,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                         Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,

                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_pipeline_executable_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,

                                                                     uint32_t *                                              pExecutableCount,

                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,

               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type

       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,

                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,

               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type

       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,

                                           PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,

                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,

                                                                     uint32_t *                                              pStatisticCount,

                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type

       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type

       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                           PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,

                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,

                                                        uint32_t *                                                          pInternalRepresentationCount,

                                                        VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,

               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<

       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type

       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

                                                        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,

               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,

                                                    VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,

                                       int>::type                            = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<

       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type

       getPipelineExecutableInternalRepresentationsKHR(

         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,

         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,

         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_host_image_copy ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo,

                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo,

                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo,

                            Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t                                                       transitionCount,

                                                           const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,

                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,

                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR

                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_map_memory2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,

                                                void **                                        ppData,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo,

                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,

                             Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,

                           Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_swapchain_maintenance1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_generated_commands ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,

                                                    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,

                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,

                                                                 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type

       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type

       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,

                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,

                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                      indirectCommandsLayout,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_private_data ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                           VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type

       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type

       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,

                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                    uint64_t                              objectHandle,

                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                    uint64_t                              data,

                                                    Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                             uint64_t                              objectHandle,

                                                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                             uint64_t                              data,

                                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                             uint64_t                              objectHandle,

                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                             uint64_t *                            pData,

                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,

                                                      uint64_t                              objectHandle,

                                                      VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,

                                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_encode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,

                                            VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,

                                            size_t *                                                             pDataSize,

                                            void *                                                               pData,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type

       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type

       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,

                                            Uint8_tAllocator &                                                   uint8_tAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X,

               typename Y,

               typename... Z,

               typename Uint8_tAllocator = std::allocator<uint8_t>,

               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type

       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X,

               typename Y,

               typename... Z,

               typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type

       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,

                                            Uint8_tAllocator &                                                   uint8_tAllocator,

                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_ENABLE_BETA_EXTENSIONS )

     //=== VK_NV_cuda_kernel_launch ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo,

                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,

                                                     VULKAN_HPP_NAMESPACE::CudaModuleNV *                 pModule,

                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type

       createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type

       createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,

                                                       size_t *                           pCacheSize,

                                                       void *                             pCacheData,

                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV(

       VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::CudaFunctionNV *                 pFunction,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type

       createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type

       createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,

                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,

                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/


 #if defined( VK_USE_PLATFORM_METAL_EXT )

     //=== VK_EXT_metal_objects ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,

                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT

                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_METAL_EXT*/


     //=== VK_EXT_descriptor_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                         VULKAN_HPP_NAMESPACE::DeviceSize *        pLayoutSizeInBytes,

                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize

                          getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                  uint32_t                                  binding,

                                                  VULKAN_HPP_NAMESPACE::DeviceSize *        pOffset,

                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize

                          getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,

                                                                  uint32_t                                  binding,

                                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,

                            size_t                                             dataSize,

                            void *                                             pDescriptor,

                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,

                            size_t                                             dataSize,

                            void *                                             pDescriptor,

                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,

                                                void *                                                           pData,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,

                                                                         void *                                                          pData,

                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,

                                               Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,

                                                   void *                                                              pData,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,

                                                 void *                                                            pData,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,

                                                               void *                                                                          pData,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_device_fault ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,

                                                  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *   pFaultInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>

                          getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_external_memory ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,

                                                               zx_handle_t *                                                  pZirconHandle,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type

       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,

                                     Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,

                                               zx_handle_t                                                 zirconHandle,

                                               VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type

       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,

                                               zx_handle_t                                            zirconHandle,

                                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_external_semaphore ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,

                                           Dispatch const & d                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,

                                                                  zx_handle_t *                                                     pZirconHandle,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type

       getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,

                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_buffer_collection ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type

       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type

       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,

                                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,

                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,

                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,

                                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,

                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,

                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,

                                                                       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type

       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,

                                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_FUCHSIA*/


     //=== VK_HUAWEI_subpass_shading ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,

                                                VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,

                                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>

       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_external_memory_rdma ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,

                                                           VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type

       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,

                                 Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_pipeline_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo,

                                                           VULKAN_HPP_NAMESPACE::BaseOutStructure *      pPipelineProperties,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type

       getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_opacity_micromap ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::MicromapEXT *                 pMicromap,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type

       createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type

       createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,

                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                                   micromap,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR         deferredOperation,

                                                    uint32_t                                           infoCount,

                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result

                          buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                 deferredOperation,

                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,

                                                  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,

                                                                        const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,

                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                          const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                                                const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,

                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                          const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,

                                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,

                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,

                                                              const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,

                                                              VULKAN_HPP_NAMESPACE::QueryType           queryType,

                                                              size_t                                    dataSize,

                                                              void *                                    pData,

                                                              size_t                                    stride,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type

       writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                    VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                    size_t                                                                            dataSize,

                                    size_t                                                                            stride,

                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type

       writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,

                                  VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,

                                  size_t                                                                            stride,

                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *          pVersionInfo,

                                       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR

                          getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,

                                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,

                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *      pBuildInfo,

                                    VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *       pSizeInfo,

                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT

                          getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,

                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT &      buildInfo,

                                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_pageable_device_local_memory ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,

                                float                              priority,

                                Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


     //=== VK_KHR_maintenance4 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,

                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,

                                               uint32_t *                                                  pSparseMemoryRequirementCount,

                                               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>

                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,

                                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,

                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VALVE_descriptor_set_host_mapping ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,

                                                      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE

                          getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,

                                            void **                             ppData,

                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_device_generated_commands_compute ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo,

                                                   VULKAN_HPP_NAMESPACE::MemoryRequirements2 *             pMemoryRequirements,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2

                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info,

                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_shader_module_identifier ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,

                                        VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,

                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT

                          getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,

                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,

                                                  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *    pIdentifier,

                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT

                          getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,

                                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,

                                                             VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *                 pSession,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type

       createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type

       createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,

                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                                                VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,

                                                                VULKAN_HPP_NAMESPACE::ImageView                        view,

                                                                VULKAN_HPP_NAMESPACE::ImageLayout                      layout,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

          bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,

                                         VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,

                                         VULKAN_HPP_NAMESPACE::ImageView                        view,

                                         VULKAN_HPP_NAMESPACE::ImageLayout                      layout,

                                         Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     //=== VK_KHR_maintenance5 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo,

                                          VULKAN_HPP_NAMESPACE::Extent2D *                   pGranularity,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D

                          getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo,

                                                          Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo,

                                        VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *               pLayout,

                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR

                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,

                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,

                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,

                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR

                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,

                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,

                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_shader_object ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t                                          createInfoCount,

                                                   const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos,

                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                                   VULKAN_HPP_NAMESPACE::ShaderEXT *                 pShaders,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type

       createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,

               typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type

       createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,

                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,

                         ShaderEXTAllocator &                                                                      shaderEXTAllocator,

                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderEXT>::type

       createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,

                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type

       createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename ShaderEXTAllocator        = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,

               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value,

                                       int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type

       createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,

                               ShaderEXTAllocator &                                                                      shaderEXTAllocator,

                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::type

       createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,

                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,

                                                         size_t *                        pDataSize,

                                                         void *                          pData,

                                                         Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type

       getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,

               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT(

       VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_QCOM_tile_properties ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer          framebuffer,

                                                                   uint32_t *                                 pPropertiesCount,

                                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,

               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type

       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,

       typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type

       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,

                                         TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,

                                         Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,

                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *  pProperties,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM

                          getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,

                                                                 Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_low_latency2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                                                        const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                                                                 const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,

                                                 const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,

                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,

                                                          const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,

                                                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,

                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,

                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR             swapchain,

                               VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,

                               Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV

                          getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,

                                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

     //=== VK_QNX_external_memory_screen_buffer ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer *                     buffer,

                                                               VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type

       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/


     //=== VK_KHR_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t                                                 timestampCount,

                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,

                                                             uint64_t *                                               pTimestamps,

                                                             uint64_t *                                               pMaxDeviation,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type

       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,

               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type

       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,

                                   Uint64_tAllocator &                                                                              uint64_tAllocator,

                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type

       getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,

                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkDevice() const VULKAN_HPP_NOEXCEPT

     {

       return m_device;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_device != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_device == VK_NULL_HANDLE;

     }


   private:

     VkDevice m_device = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::Device;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::Device;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class DisplayModeKHR

   {

   public:

     using CType      = VkDisplayModeKHR;

     using NativeType = VkDisplayModeKHR;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;


   public:

     VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;


     VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}


 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )

     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT

     {

       m_displayModeKHR = displayModeKHR;

       return *this;

     }

 #endif


     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_displayModeKHR = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( DisplayModeKHR const & ) const = default;

 #else

     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR == rhs.m_displayModeKHR;

     }


     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR != rhs.m_displayModeKHR;

     }


     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR < rhs.m_displayModeKHR;

     }

 #endif


     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_displayModeKHR == VK_NULL_HANDLE;

     }


   private:

     VkDisplayModeKHR m_displayModeKHR = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>

   {

     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class PhysicalDevice

   {

   public:

     using CType      = VkPhysicalDevice;

     using NativeType = VkPhysicalDevice;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;


   public:

     VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;


     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}


     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT

     {

       m_physicalDevice = physicalDevice;

       return *this;

     }


     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_physicalDevice = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( PhysicalDevice const & ) const = default;

 #else

     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice == rhs.m_physicalDevice;

     }


     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice != rhs.m_physicalDevice;

     }


     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice < rhs.m_physicalDevice;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,

                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures

                          getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,

                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,

                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties

       getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,

                                                           VULKAN_HPP_NAMESPACE::ImageType               type,

                                                           VULKAN_HPP_NAMESPACE::ImageTiling             tiling,

                                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,

                                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,

                                                           VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type

       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,

                                 VULKAN_HPP_NAMESPACE::ImageType              type,

                                 VULKAN_HPP_NAMESPACE::ImageTiling            tiling,

                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,

                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                 Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,

                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties

                          getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,

                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,

                                    Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>

                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,

                                       int>::type      = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>

                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,

                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,

                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties

                          getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,

                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                               VULKAN_HPP_NAMESPACE::Device *                    pDevice,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type

       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,

                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type

       createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char *                                pLayerName,

                                                                     uint32_t *                                  pPropertyCount,

                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type

       enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

       typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type

       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,

                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,

                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,

                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,

               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,

                                          VULKAN_HPP_NAMESPACE::ImageType                     type,

                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,

                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,

                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,

                                          uint32_t *                                          pPropertyCount,

                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,

               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>

                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,

                                                          VULKAN_HPP_NAMESPACE::ImageType           type,

                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,

                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,

                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,

       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,

                               int>::type            = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>

                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,

                                                          VULKAN_HPP_NAMESPACE::ImageType           type,

                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,

                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,

                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,

                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,

                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2

                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,

                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2

                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,

                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,

                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2

       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,

                                                            VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type

       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,

                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,

                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,

                                       int>::type       = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,

                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

       getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,

                                Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2

                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,

                                           uint32_t *                                                         pPropertyCount,

                                           VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                           SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,

                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,

                                       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,

                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties

                          getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,

                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,

                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties

                          getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,

                                          VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties

                          getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_3 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t *                                           pToolCount,

                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,

                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,

                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR surface,

                                                       VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,

                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR(

       uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,

                                                            VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type

       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,

                                                       uint32_t *                               pSurfaceFormatCount,

                                                       VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,

               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type

       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,

       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type

       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,

                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,

                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,

                                                            uint32_t *                             pPresentModeCount,

                                                            VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,

                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,

                                  PresentModeKHRAllocator &        presentModeKHRAllocator,

                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_swapchain ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,

                                                          uint32_t *                       pRectCount,

                                                          VULKAN_HPP_NAMESPACE::Rect2D *   pRects,

                                                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type

       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,

               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR(

       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,

                                                          VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,

               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type

       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,

               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,

                                       int>::type     = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type

       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,

                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,

                                                               VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,

               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type

       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,

       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,

                               int>::type          = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type

       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,

                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,

                                                                      uint32_t *                         pDisplayCount,

                                                                      VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,

                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type

       getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,

               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(

       uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,

                                                              uint32_t *                                       pPropertyCount,

                                                              VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,

               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type

       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,

       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,

                               int>::type         = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type

       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,

                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,

                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,

                                                       const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type

       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,

                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type

       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,

                                   const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,

                                                                 uint32_t                                            planeIndex,

                                                                 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR(

       VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

     //=== VK_KHR_xlib_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                           Display *          dpy,

                                           VisualID           visualID,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                                                 Display &          dpy,

                                                                 VisualID           visualID,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

     //=== VK_KHR_xcb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                          xcb_connection_t * connection,

                                          xcb_visualid_t     visual_id,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,

                                                                xcb_connection_t & connection,

                                                                xcb_visualid_t     visual_id,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

     //=== VK_KHR_wayland_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,

                                              struct wl_display * display,

                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,

                                                                    struct wl_display & display,

                                                                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_win32_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_KHR_video_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,

                                                          VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *      pCapabilities,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type

       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,

                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,

                                                              uint32_t *                                                     pVideoFormatPropertyCount,

                                                              VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,

                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,

               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type

       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,

                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,

       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,

                               int>::type         = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type

       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,

                                    VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,

                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_external_memory_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                            format,

                                                                     VULKAN_HPP_NAMESPACE::ImageType                         type,

                                                                     VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,

                                                                     VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,

                                                                     VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,

                                                                     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,

                                                                     VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type

       getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                                             format,

                                           VULKAN_HPP_NAMESPACE::ImageType                                          type,

                                           VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,

                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,

                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_physical_device_properties2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,

                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2

                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,

                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2

                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,

                                   VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,

                                   Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2

       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,

                                                               VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type

       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,

                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,

                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,

                                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,

               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,

                                       int>::type       = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>

                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,

                                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>

       getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,

                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2

                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>

                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,

                                              uint32_t *                                                         pPropertyCount,

                                              VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,

                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>

                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,

                                                              SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,

                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_memory_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,

                                          VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,

                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties

                          getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_semaphore_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,

                                             VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,

                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties

                          getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_direct_mode_display ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )

     //=== VK_EXT_acquire_xlib_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display *                        dpy,

                                                        VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display *                          dpy,

                                                           RROutput                           rrOutput,

                                                           VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/


     //=== VK_EXT_display_surface_counter ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,

                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type

       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_external_fence_capabilities ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,

                                         VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties

                          getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_performance_query ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                                 queueFamilyIndex,

                                                        uint32_t *                                               pCounterCount,

                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,

                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,

               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,

               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,

                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type

       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,

               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,

               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&

                   std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,

                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type

       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                    queueFamilyIndex,

                                                        PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,

                                                        PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,

                                                        Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,

                                                   uint32_t *                                                      pNumPasses,

                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD uint32_t

       getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_surface_capabilities2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type

       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                        uint32_t *                                                  pSurfaceFormatCount,

                                                        VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,

               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type

       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,

       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type

       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,

                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type

       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename StructureChain,

               typename StructureChainAllocator = std::allocator<StructureChain>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type

       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                              StructureChainAllocator &                                   structureChainAllocator,

                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_get_display_properties2 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,

                                                           VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type

       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,

               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value,

                                       int>::type      = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type

       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,

                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,

                                                                VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,

               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type

       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,

       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,

                               int>::type           = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type

       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,

                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,

                                                               uint32_t *                                        pPropertyCount,

                                                               VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,

               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type

       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <

       typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,

       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

       typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,

                               int>::type          = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type

       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,

                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,

                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,

                                                                  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,

                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type

       getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,

                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_sample_locations ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,

                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,

                                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT

                          getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,

                                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,

                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type

       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,

               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type

       getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_fragment_shading_rate ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t *                                                   pFragmentShadingRateCount,

                                                             VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type

       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,

                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,

                                       int>::type                     = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type

       getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,

                                   Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_EXT_tooling_info ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t *                                           pToolCount,

                                                       VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,

               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type

       getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,

                             Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_cooperative_matrix ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t *                                            pPropertyCount,

                                                                   VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type

       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type

       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_NV_coverage_reduction_mode ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t *                                                   pCombinationCount,

                                                          VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type

       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,

               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,

                                                    VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,

                                       int>::type                     = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type

       getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,

                                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_EXT_full_screen_exclusive ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,

                                                             uint32_t *                                                  pPresentModeCount,

                                                             VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,

                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type

       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,

                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,

                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_EXT_acquire_drm_display ===


 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t                          drmFd,

                                                       VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     typename ResultValueType<void>::type

          acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t                            drmFd,

                                                   uint32_t                           connectorId,

                                                   VULKAN_HPP_NAMESPACE::DisplayKHR * display,

                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_video_encode_queue ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result

       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,

                                                VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR *               pQualityLevelProperties,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type

       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type

       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,

                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_NV_acquire_winrt_display ===


 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,

                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  else

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type

       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t                           deviceRelativeId,

                                                    VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,

                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type

       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type

       getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

     //=== VK_EXT_directfb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,

                                               IDirectFB *        dfb,

                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,

                                                                     IDirectFB &        dfb,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

     //=== VK_QNX_screen_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,

                                             struct _screen_window * window,

                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,

                                                                   struct _screen_window & window,

                                                                   Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/


     //=== VK_NV_optical_flow ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,

                                                               uint32_t *                                                 pFormatCount,

                                                               VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,

               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type

       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,

                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,

               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type

       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,

                                     OpticalFlowImageFormatPropertiesNVAllocator &              opticalFlowImageFormatPropertiesNVAllocator,

                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_cooperative_matrix ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t *                                             pPropertyCount,

                                                                    VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties,

                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type

       getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,

               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type

       getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,

                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_calibrated_timestamps ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t *                            pTimeDomainCount,

                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type

       getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,

               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type

       getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_physicalDevice == VK_NULL_HANDLE;

     }


   private:

     VkPhysicalDevice m_physicalDevice = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>

   {

     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   class Instance

   {

   public:

     using CType      = VkInstance;

     using NativeType = VkInstance;


     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;

     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =

       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;


   public:

     VULKAN_HPP_CONSTEXPR Instance() = default;


     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}


     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}


     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT

     {

       m_instance = instance;

       return *this;

     }


     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

     {

       m_instance = {};

       return *this;

     }


 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

     auto operator<=>( Instance const & ) const = default;

 #else

     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance == rhs.m_instance;

     }


     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance != rhs.m_instance;

     }


     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT

     {

       return m_instance < rhs.m_instance;

     }

 #endif


     //=== VK_VERSION_1_0 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,

                                                           VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type

       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,

               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>

     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type

       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_VERSION_1_1 ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t *                                            pPhysicalDeviceGroupCount,

                                                                VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,

                                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,

                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface                            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                                    surface,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     //=== VK_KHR_display ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,

                                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_XLIB_KHR )

     //=== VK_KHR_xlib_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,

                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,

                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,

                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,

                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,

                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/


 #if defined( VK_USE_PLATFORM_XCB_KHR )

     //=== VK_KHR_xcb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_XCB_KHR*/


 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

     //=== VK_KHR_wayland_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,

                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/


 #if defined( VK_USE_PLATFORM_ANDROID_KHR )

     //=== VK_KHR_android_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,

                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,

                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,

                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/


 #if defined( VK_USE_PLATFORM_WIN32_KHR )

     //=== VK_KHR_win32_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/


     //=== VK_EXT_debug_report ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                               VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type

       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type

       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,

                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                        callback,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,

                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,

                                 uint64_t                                       object,

                                 size_t                                         location,

                                 int32_t                                        messageCode,

                                 const char *                                   pLayerPrefix,

                                 const char *                                   pMessage,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,

                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,

                                 uint64_t                                       object,

                                 size_t                                         location,

                                 int32_t                                        messageCode,

                                 const std::string &                            layerPrefix,

                                 const std::string &                            message,

                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_GGP )

     //=== VK_GGP_stream_descriptor_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,

                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,

                                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(

       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,

       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_GGP*/


 #if defined( VK_USE_PLATFORM_VI_NN )

     //=== VK_NN_vi_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,

                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,

                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,

                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,

                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,

                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_VI_NN*/


     //=== VK_KHR_device_group_creation ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t *                                            pPhysicalDeviceGroupCount,

                                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,

                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,

               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

               typename std::enable_if<

                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,

                 int>::type = 0>

     VULKAN_HPP_NODISCARD

       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type

       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,

                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_IOS_MVK )

     //=== VK_MVK_ios_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,

                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,

                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,

                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,

                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,

                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_IOS_MVK*/


 #if defined( VK_USE_PLATFORM_MACOS_MVK )

     //=== VK_MVK_macos_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/


     //=== VK_EXT_debug_utils ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,

                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,

                                                               VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,

                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type

       createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type

       createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,

                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,

                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,

                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,

                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                        messenger,

                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,

                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,

                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,

                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,

                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,

                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,

                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_FUCHSIA )

     //=== VK_FUCHSIA_imagepipe_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,

                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,

                                                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,

                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,

                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,

                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_FUCHSIA*/


 #if defined( VK_USE_PLATFORM_METAL_EXT )

     //=== VK_EXT_metal_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,

                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,

                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,

                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,

                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,

                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_METAL_EXT*/


     //=== VK_EXT_headless_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,

                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

     //=== VK_EXT_directfb_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,

                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,

                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,

                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,

                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,

                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/


 #if defined( VK_USE_PLATFORM_SCREEN_QNX )

     //=== VK_QNX_screen_surface ===


     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,

                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,

                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type

       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,

                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    ifndef VULKAN_HPP_NO_SMART_HANDLE

     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type

       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,

                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/


     operator VkInstance() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance;

     }


     explicit operator bool() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance != VK_NULL_HANDLE;

     }


     bool operator!() const VULKAN_HPP_NOEXCEPT

     {

       return m_instance == VK_NULL_HANDLE;

     }


   private:

     VkInstance m_instance = {};

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>

   {

     using Type = VULKAN_HPP_NAMESPACE::Instance;

   };


   template <>

   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>

   {

     using Type = VULKAN_HPP_NAMESPACE::Instance;

   };


   template <>

   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>

   {

     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

   };


   //=== VK_VERSION_1_0 ===


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,

                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,

                                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type

     createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,

                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #  ifndef VULKAN_HPP_NO_SMART_HANDLE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type

     createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,

                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char *                                pLayerName,

                                                                     uint32_t *                                  pPropertyCount,

                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,

                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type

     enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,

                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

   template <

     typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,

     typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

     typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type

     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,

                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,

                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,

                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,

                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,

             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,

             typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>

   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type

     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


   //=== VK_VERSION_1_1 ===


   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t *         pApiVersion,

                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

   VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


 }  // namespace VULKAN_HPP_NAMESPACE


 // operators to compare vk::-handles with nullptr

 template <typename T>

 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )

 {

   return !v;

 }


 template <typename T>

 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )

 {

   return !v;

 }


 template <typename T>

 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )

 {

   return v;

 }


 template <typename T>

 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )

 {

   return v;

 }

 #endif

vk::AccelerationStructureKHR
Definition: vulkan_handles.hpp:4091

vk::AccelerationStructureKHR::NativeType
VkAccelerationStructureKHR NativeType
Definition: vulkan_handles.hpp:4094

vk::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4103

vk::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4105

vk::AccelerationStructureKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4153

vk::AccelerationStructureKHR::CType
VkAccelerationStructureKHR CType
Definition: vulkan_handles.hpp:4093

vk::AccelerationStructureKHR::operator<
bool operator<(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4137

vk::AccelerationStructureKHR::operator==
bool operator==(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4127

vk::AccelerationStructureKHR::operator=
AccelerationStructureKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4118

vk::AccelerationStructureKHR::AccelerationStructureKHR
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR()=default

vk::AccelerationStructureKHR::operator!=
bool operator!=(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4132

vk::AccelerationStructureNV
Definition: vulkan_handles.hpp:3738

vk::AccelerationStructureNV::NativeType
VkAccelerationStructureNV NativeType
Definition: vulkan_handles.hpp:3741

vk::AccelerationStructureNV::operator!=
bool operator!=(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3779

vk::AccelerationStructureNV::operator==
bool operator==(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3774

vk::AccelerationStructureNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3800

vk::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()=default

vk::AccelerationStructureNV::CType
VkAccelerationStructureNV CType
Definition: vulkan_handles.hpp:3740

vk::AccelerationStructureNV::operator<
bool operator<(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3784

vk::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3752

vk::AccelerationStructureNV::AccelerationStructureNV
VULKAN_HPP_CONSTEXPR AccelerationStructureNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3750

vk::AccelerationStructureNV::operator=
AccelerationStructureNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3765

vk::BufferView
Definition: vulkan_handles.hpp:6967

vk::BufferView::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7026

vk::BufferView::CType
VkBufferView CType
Definition: vulkan_handles.hpp:6969

vk::BufferView::BufferView
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6981

vk::BufferView::BufferView
VULKAN_HPP_CONSTEXPR BufferView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6979

vk::BufferView::operator<
bool operator<(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7010

vk::BufferView::NativeType
VkBufferView NativeType
Definition: vulkan_handles.hpp:6970

vk::BufferView::operator!=
bool operator!=(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7005

vk::BufferView::operator==
bool operator==(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7000

vk::BufferView::BufferView
VULKAN_HPP_CONSTEXPR BufferView()=default

vk::BufferView::operator=
BufferView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6991

vk::Buffer
Definition: vulkan_handles.hpp:3135

vk::Buffer::operator=
Buffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3159

vk::Buffer::Buffer
VULKAN_HPP_CONSTEXPR Buffer()=default

vk::Buffer::NativeType
VkBuffer NativeType
Definition: vulkan_handles.hpp:3138

vk::Buffer::operator==
bool operator==(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3168

vk::Buffer::Buffer
VULKAN_HPP_CONSTEXPR Buffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3147

vk::Buffer::operator<
bool operator<(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3178

vk::Buffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3194

vk::Buffer::CType
VkBuffer CType
Definition: vulkan_handles.hpp:3137

vk::Buffer::operator!=
bool operator!=(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3173

vk::Buffer::Buffer
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3149

vk::CommandBuffer
Definition: vulkan_handles.hpp:4262

vk::CommandBuffer::decompressMemoryNV
void decompressMemoryNV(vk::ArrayProxy< const vk::DecompressMemoryRegionNV > const &decompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissor
void setScissor(uint32_t firstScissor, vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginConditionalRenderingEXT
void beginConditionalRenderingEXT(const vk::ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawClusterHUAWEI
void drawClusterHUAWEI(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendAdvancedEXT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorBlendAdvancedEXT > const &colorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::controlVideoCodingKHR
void controlVideoCodingKHR(const vk::VideoCodingControlInfoKHR *pCodingControlInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::decompressMemoryNV
void decompressMemoryNV(uint32_t decompressRegionCount, const vk::DecompressMemoryRegionNV *pDecompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::encodeVideoKHR
void encodeVideoKHR(const vk::VideoEncodeInfoKHR &encodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMeshTasksIndirectEXT
void drawMeshTasksIndirectEXT(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setRayTracingPipelineStackSizeKHR
void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeMicromapsPropertiesEXT
void writeMicromapsPropertiesEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::opticalFlowExecuteNV
void opticalFlowExecuteNV(vk::OpticalFlowSessionNV session, const vk::OpticalFlowExecuteInfoNV &executeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier
void pipelineBarrier(vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, vk::ArrayProxy< const vk::MemoryBarrier > const &memoryBarriers, vk::ArrayProxy< const vk::BufferMemoryBarrier > const &bufferMemoryBarriers, vk::ArrayProxy< const vk::ImageMemoryBarrier > const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSet2KHR
void pushDescriptorSet2KHR(const vk::PushDescriptorSetInfoKHR *pPushDescriptorSetInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPrimitiveTopology
void setPrimitiveTopology(vk::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBuffer2KHR
void copyBuffer2KHR(const vk::CopyBufferInfo2 &copyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::traceRaysNV
void traceRaysNV(vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setExclusiveScissorNV
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D *pExclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndirect
void drawIndirect(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthClipNegativeOneToOneEXT
void setDepthClipNegativeOneToOneEXT(vk::Bool32 negativeOneToOne, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBiasEnableEXT
void setDepthBiasEnableEXT(vk::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderPass2KHR
void endRenderPass2KHR(const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBuffer2
void copyBuffer2(const vk::CopyBufferInfo2 &copyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents2
void waitEvents2(uint32_t eventCount, const vk::Event *pEvents, const vk::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setExclusiveScissorEnableNV
void setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor, vk::ArrayProxy< const vk::Bool32 > const &exclusiveScissorEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendAdvancedEXT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorBlendAdvancedEXT *pColorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::opticalFlowExecuteNV
void opticalFlowExecuteNV(vk::OpticalFlowSessionNV session, const vk::OpticalFlowExecuteInfoNV *pExecuteInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass2
void beginRenderPass2(const vk::RenderPassBeginInfo &renderPassBegin, const vk::SubpassBeginInfo &subpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSetWithTemplate2KHR
void pushDescriptorSetWithTemplate2KHR(const vk::PushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::nextSubpass
void nextSubpass(vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::CommandBuffer
CommandBuffer(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4276

vk::CommandBuffer::traceRaysIndirectKHR
void traceRaysIndirectKHR(const vk::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endDebugUtilsLabelEXT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryIndirectNV
void copyMemoryIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::NativeType
VkCommandBuffer NativeType
Definition: vulkan_handles.hpp:4265

vk::CommandBuffer::setLineStippleEXT
void setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissorWithCountEXT
void setScissorWithCountEXT(vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructuresKHR
void buildAccelerationStructuresKHR(vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::AccelerationStructureBuildRangeInfoKHR *const > const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::setPolygonModeEXT
void setPolygonModeEXT(vk::PolygonMode polygonMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissorWithCountEXT
void setScissorWithCountEXT(uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderingKHR
void beginRenderingKHR(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushConstants2KHR
void pushConstants2KHR(const vk::PushConstantsInfoKHR &pushConstantsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers
void bindVertexBuffers(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::copyBufferToImage2
void copyBufferToImage2(const vk::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImageToBuffer2
void copyImageToBuffer2(const vk::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setEvent2
void setEvent2(vk::Event event, const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::debugMarkerInsertEXT
void debugMarkerInsertEXT(const vk::DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::preprocessGeneratedCommandsNV
void preprocessGeneratedCommandsNV(const vk::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthTestEnableEXT
void setDepthTestEnableEXT(vk::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderingKHR
void beginRenderingKHR(const vk::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWScalingNV
void setViewportWScalingNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ViewportWScalingNV > const &viewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setAlphaToOneEnableEXT
void setAlphaToOneEnableEXT(vk::Bool32 alphaToOneEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceStreamMarkerINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceStreamMarkerINTEL(const vk::PerformanceStreamMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::setDepthBias2EXT
void setDepthBias2EXT(const vk::DepthBiasInfoEXT *pDepthBiasInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::subpassShadingHUAWEI
void subpassShadingHUAWEI(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWithCountEXT
void setViewportWithCountEXT(vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndexedIndirect
void drawIndexedIndirect(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageToColorLocationNV
void setCoverageToColorLocationNV(uint32_t coverageToColorLocation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthCompareOp
void setDepthCompareOp(vk::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage2KHR
void blitImage2KHR(const vk::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBufferToImage2KHR
void copyBufferToImage2KHR(const vk::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMultiEXT
void drawMultiEXT(vk::StridedArrayProxy< const vk::MultiDrawInfoEXT > const &vertexInfo, uint32_t instanceCount, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDescriptorBufferOffsetsEXT
void setDescriptorBufferOffsetsEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, vk::ArrayProxy< const uint32_t > const &bufferIndices, vk::ArrayProxy< const vk::DeviceSize > const &offsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::pushDescriptorSetKHR
void pushDescriptorSetKHR(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, vk::ArrayProxy< const vk::WriteDescriptorSet > const &descriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDeviceMask
void setDeviceMask(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorBuffersEXT
void bindDescriptorBuffersEXT(vk::ArrayProxy< const vk::DescriptorBufferBindingInfoEXT > const &bindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::traceRaysKHR
void traceRaysKHR(const vk::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setConservativeRasterizationModeEXT
void setConservativeRasterizationModeEXT(vk::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginVideoCodingKHR
void beginVideoCodingKHR(const vk::VideoBeginCodingInfoKHR &beginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setTessellationDomainOriginEXT
void setTessellationDomainOriginEXT(vk::TessellationDomainOrigin domainOrigin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructuresIndirectKHR
void buildAccelerationStructuresIndirectKHR(vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::DeviceAddress > const &indirectDeviceAddresses, vk::ArrayProxy< const uint32_t > const &indirectStrides, vk::ArrayProxy< const uint32_t *const > const &pMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::copyImage2
void copyImage2(const vk::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resolveImage
void resolveImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageResolve > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawClusterIndirectHUAWEI
void drawClusterIndirectHUAWEI(vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setExclusiveScissorEnableNV
void setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Bool32 *pExclusiveScissorEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImageToBuffer
void copyImageToBuffer(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, vk::ArrayProxy< const vk::BufferImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::nextSubpass2KHR
void nextSubpass2KHR(const vk::SubpassBeginInfo &subpassBeginInfo, const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setEvent2KHR
void setEvent2KHR(vk::Event event, const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage2
void blitImage2(const vk::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::end
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::copyImageToBuffer2KHR
void copyImageToBuffer2KHR(const vk::CopyImageToBufferInfo2 &copyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBounds
void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginTransformFeedbackEXT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer *pCounterBuffers, const vk::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendEquationEXT
void setColorBlendEquationEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorBlendEquationEXT *pColorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissorWithCount
void setScissorWithCount(uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::draw
void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setLogicOpEnableEXT
void setLogicOpEnableEXT(vk::Bool32 logicOpEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::traceRaysKHR
void traceRaysKHR(const vk::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &missShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &hitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &callableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::encodeVideoKHR
void encodeVideoKHR(const vk::VideoEncodeInfoKHR *pEncodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator=
CommandBuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4284

vk::CommandBuffer::drawIndexedIndirectCountAMD
void drawIndexedIndirectCountAMD(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageReductionModeNV
void setCoverageReductionModeNV(vk::CoverageReductionModeNV coverageReductionMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthClampEnableEXT
void setDepthClampEnableEXT(vk::Bool32 depthClampEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::fillBuffer
void fillBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindTransformFeedbackBuffersEXT
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::bindTransformFeedbackBuffersEXT
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::clearDepthStencilImage
void clearDepthStencilImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue &depthStencil, vk::ArrayProxy< const vk::ImageSubresourceRange > const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers2
void bindVertexBuffers2(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, vk::ArrayProxy< const vk::DeviceSize > const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::bindDescriptorSets2KHR
void bindDescriptorSets2KHR(const vk::BindDescriptorSetsInfoKHR &bindDescriptorSetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilOpEXT
void setStencilOpEXT(vk::StencilFaceFlags faceMask, vk::StencilOp failOp, vk::StencilOp passOp, vk::StencilOp depthFailOp, vk::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBuffer
void copyBuffer(vk::Buffer srcBuffer, vk::Buffer dstBuffer, vk::ArrayProxy< const vk::BufferCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBoundsTestEnable
void setDepthBoundsTestEnable(vk::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents2KHR
void waitEvents2KHR(vk::ArrayProxy< const vk::Event > const &events, vk::ArrayProxy< const vk::DependencyInfo > const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::bindDescriptorSets
void bindDescriptorSets(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginTransformFeedbackEXT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, vk::ArrayProxy< const vk::Buffer > const &counterBuffers, vk::ArrayProxy< const vk::DeviceSize > const &counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::setViewportWScalingEnableNV
void setViewportWScalingEnableNV(vk::Bool32 viewportWScalingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents2KHR
void waitEvents2KHR(uint32_t eventCount, const vk::Event *pEvents, const vk::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceOverrideINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceOverrideINTEL(const vk::PerformanceOverrideInfoINTEL &overrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::setDeviceMaskKHR
void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::debugMarkerEndEXT
void debugMarkerEndEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBuffer2
void copyBuffer2(const vk::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginVideoCodingKHR
void beginVideoCodingKHR(const vk::VideoBeginCodingInfoKHR *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissorWithCount
void setScissorWithCount(vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryToImageIndirectNV
void copyMemoryToImageIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, vk::Image dstImage, vk::ImageLayout dstImageLayout, const vk::ImageSubresourceLayers *pImageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructureNV
void buildAccelerationStructureNV(const vk::AccelerationStructureInfoNV *pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndirectCountKHR
void drawIndirectCountKHR(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImageToBuffer2
void copyImageToBuffer2(const vk::CopyImageToBufferInfo2 &copyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMeshTasksIndirectNV
void drawMeshTasksIndirectNV(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setRasterizerDiscardEnableEXT
void setRasterizerDiscardEnableEXT(vk::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents
void waitEvents(vk::ArrayProxy< const vk::Event > const &events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::ArrayProxy< const vk::MemoryBarrier > const &memoryBarriers, vk::ArrayProxy< const vk::BufferMemoryBarrier > const &bufferMemoryBarriers, vk::ArrayProxy< const vk::ImageMemoryBarrier > const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::decodeVideoKHR
void decodeVideoKHR(const vk::VideoDecodeInfoKHR *pDecodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::controlVideoCodingKHR
void controlVideoCodingKHR(const vk::VideoCodingControlInfoKHR &codingControlInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setAlphaToCoverageEnableEXT
void setAlphaToCoverageEnableEXT(vk::Bool32 alphaToCoverageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeTimestamp2
void writeTimestamp2(vk::PipelineStageFlags2 stage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::executeCommands
void executeCommands(uint32_t commandBufferCount, const vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendEquationEXT
void setColorBlendEquationEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorBlendEquationEXT > const &colorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setVertexInputEXT
void setVertexInputEXT(uint32_t vertexBindingDescriptionCount, const vk::VertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const vk::VertexInputAttributeDescription2EXT *pVertexAttributeDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSetWithTemplate2KHR
void pushDescriptorSetWithTemplate2KHR(const vk::PushDescriptorSetWithTemplateInfoKHR &pushDescriptorSetWithTemplateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass
void beginRenderPass(const vk::RenderPassBeginInfo *pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setRasterizationStreamEXT
void setRasterizationStreamEXT(uint32_t rasterizationStream, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorWriteMaskEXT
void setColorWriteMaskEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorComponentFlags *pColorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setLogicOpEXT
void setLogicOpEXT(vk::LogicOp logicOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeBufferMarker2AMD
void writeBufferMarker2AMD(vk::PipelineStageFlags2 stage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier2KHR
void pipelineBarrier2KHR(const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCheckpointNV
void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPrimitiveTopologyEXT
void setPrimitiveTopologyEXT(vk::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endQuery
void endQuery(vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDiscardRectangleEnableEXT
void setDiscardRectangleEnableEXT(vk::Bool32 discardRectangleEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginConditionalRenderingEXT
void beginConditionalRenderingEXT(const vk::ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setBlendConstants
void setBlendConstants(const float blendConstants[4], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::debugMarkerBeginEXT
void debugMarkerBeginEXT(const vk::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushConstants
void pushConstants(vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, vk::ArrayProxy< const ValuesType > const &values, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindPipelineShaderGroupNV
void bindPipelineShaderGroupNV(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, uint32_t groupIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator!=
bool operator!=(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4298

vk::CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT
void bindDescriptorBufferEmbeddedSamplersEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCullMode
void setCullMode(vk::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setAttachmentFeedbackLoopEnableEXT
void setAttachmentFeedbackLoopEnableEXT(vk::ImageAspectFlags aspectMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::clearDepthStencilImage
void clearDepthStencilImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::decodeVideoKHR
void decodeVideoKHR(const vk::VideoDecodeInfoKHR &decodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImageToBuffer
void copyImageToBuffer(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMeshTasksIndirectCountEXT
void drawMeshTasksIndirectCountEXT(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers2EXT
void bindVertexBuffers2EXT(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, vk::ArrayProxy< const vk::DeviceSize > const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::copyMemoryToImageIndirectNV
void copyMemoryToImageIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t stride, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageSubresourceLayers > const &imageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeBufferMarkerAMD
void writeBufferMarkerAMD(vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDiscardRectangleEXT
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D *pDiscardRectangles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endVideoCodingKHR
void endVideoCodingKHR(const vk::VideoEndCodingInfoKHR *pEndCodingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::cuLaunchKernelNVX
void cuLaunchKernelNVX(const vk::CuLaunchInfoNVX *pLaunchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyAccelerationStructureToMemoryKHR
void copyAccelerationStructureToMemoryKHR(const vk::CopyAccelerationStructureToMemoryInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resolveImage2
void resolveImage2(const vk::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushConstants2KHR
void pushConstants2KHR(const vk::PushConstantsInfoKHR *pPushConstantsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBoundsTestEnableEXT
void setDepthBoundsTestEnableEXT(vk::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWithCountEXT
void setViewportWithCountEXT(uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setFragmentShadingRateKHR
void setFragmentShadingRateKHR(const vk::Extent2D *pFragmentSize, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::preprocessGeneratedCommandsNV
void preprocessGeneratedCommandsNV(const vk::GeneratedCommandsInfoNV &generatedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeTimestamp
void writeTimestamp(vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImageToBuffer2KHR
void copyImageToBuffer2KHR(const vk::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructuresIndirectKHR
void buildAccelerationStructuresIndirectKHR(uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::DeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyQueryPoolResults
void copyQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBufferToImage
void copyBufferToImage(vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageModulationModeNV
void setCoverageModulationModeNV(vk::CoverageModulationModeNV coverageModulationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRendering
void beginRendering(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setExtraPrimitiveOverestimationSizeEXT
void setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilWriteMask
void setStencilWriteMask(vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::begin
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type begin(const vk::CommandBufferBeginInfo &beginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::writeAccelerationStructuresPropertiesNV
void writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const vk::AccelerationStructureNV *pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::updatePipelineIndirectBufferNV
void updatePipelineIndirectBufferNV(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPrimitiveRestartEnableEXT
void setPrimitiveRestartEnableEXT(vk::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers2
void bindVertexBuffers2(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, const vk::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceMarkerINTEL
VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(const vk::PerformanceMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMicromapEXT
void copyMicromapEXT(const vk::CopyMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endConditionalRenderingEXT
void endConditionalRenderingEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT
void bindDescriptorBufferEmbeddedSamplers2EXT(const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT &bindDescriptorBufferEmbeddedSamplersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage
void blitImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageBlit > const &regions, vk::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindShadingRateImageNV
void bindShadingRateImageNV(vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPatchControlPointsEXT
void setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endTransformFeedbackEXT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer *pCounterBuffers, const vk::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceStreamMarkerINTEL
VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(const vk::PerformanceStreamMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyAccelerationStructureKHR
void copyAccelerationStructureKHR(const vk::CopyAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorSets2KHR
void bindDescriptorSets2KHR(const vk::BindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndexedIndirectCountKHR
void drawIndexedIndirectCountKHR(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPrimitiveRestartEnable
void setPrimitiveRestartEnable(vk::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setLineStippleEnableEXT
void setLineStippleEnableEXT(vk::Bool32 stippledLineEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryToMicromapEXT
void copyMemoryToMicromapEXT(const vk::CopyMemoryToMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setProvokingVertexModeEXT
void setProvokingVertexModeEXT(vk::ProvokingVertexModeEXT provokingVertexMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImage2KHR
void copyImage2KHR(const vk::CopyImageInfo2 &copyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewport
void setViewport(uint32_t firstViewport, vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass2KHR
void beginRenderPass2KHR(const vk::RenderPassBeginInfo *pRenderPassBegin, const vk::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBias2EXT
void setDepthBias2EXT(const vk::DepthBiasInfoEXT &depthBiasInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setLineRasterizationModeEXT
void setLineRasterizationModeEXT(vk::LineRasterizationModeEXT lineRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBufferToImage
void copyBufferToImage(vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::BufferImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier2
void pipelineBarrier2(const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endTransformFeedbackEXT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, vk::ArrayProxy< const vk::Buffer > const &counterBuffers, vk::ArrayProxy< const vk::DeviceSize > const &counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::pushConstants
void pushConstants(vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setScissor
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMultiEXT
void drawMultiEXT(uint32_t drawCount, const vk::MultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderingKHR
void endRenderingKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthClipEnableEXT
void setDepthClipEnableEXT(vk::Bool32 depthClipEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setFragmentShadingRateEnumNV
void setFragmentShadingRateEnumNV(vk::FragmentShadingRateNV shadingRate, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resetEvent2
void resetEvent2(vk::Event event, vk::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImage
void copyImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::begin
VULKAN_HPP_NODISCARD Result begin(const vk::CommandBufferBeginInfo *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier2KHR
void pipelineBarrier2KHR(const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMeshTasksIndirectCountNV
void drawMeshTasksIndirectCountNV(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImage2
void copyImage2(const vk::CopyImageInfo2 &copyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage2
void blitImage2(const vk::BlitImageInfo2 &blitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT
void bindDescriptorBufferEmbeddedSamplers2EXT(const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDescriptorBufferOffsets2EXT
void setDescriptorBufferOffsets2EXT(const vk::SetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::dispatchBase
void dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndexed
void drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setRepresentativeFragmentTestEnableNV
void setRepresentativeFragmentTestEnableNV(vk::Bool32 representativeFragmentTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthTestEnable
void setDepthTestEnable(vk::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageModulationTableNV
void setCoverageModulationTableNV(vk::ArrayProxy< const float > const &coverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSet2KHR
void pushDescriptorSet2KHR(const vk::PushDescriptorSetInfoKHR &pushDescriptorSetInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWithCount
void setViewportWithCount(uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::clearAttachments
void clearAttachments(uint32_t attachmentCount, const vk::ClearAttachment *pAttachments, uint32_t rectCount, const vk::ClearRect *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::clearColorImage
void clearColorImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue &color, vk::ArrayProxy< const vk::ImageSubresourceRange > const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMicromapEXT
void copyMicromapEXT(const vk::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildMicromapsEXT
void buildMicromapsEXT(uint32_t infoCount, const vk::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::debugMarkerInsertEXT
void debugMarkerInsertEXT(const vk::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportSwizzleNV
void setViewportSwizzleNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ViewportSwizzleNV > const &viewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImage2KHR
void copyImage2KHR(const vk::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindIndexBuffer
void bindIndexBuffer(vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers
void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::CommandBuffer
VULKAN_HPP_CONSTEXPR CommandBuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4274

vk::CommandBuffer::setViewportShadingRatePaletteNV
void setViewportShadingRatePaletteNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ShadingRatePaletteNV > const &shadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator=
CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4278

vk::CommandBuffer::setRasterizerDiscardEnable
void setRasterizerDiscardEnable(vk::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::nextSubpass2
void nextSubpass2(const vk::SubpassBeginInfo *pSubpassBeginInfo, const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyAccelerationStructureKHR
void copyAccelerationStructureKHR(const vk::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setSampleMaskEXT
void setSampleMaskEXT(vk::SampleCountFlagBits samples, const vk::SampleMask *pSampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindPipeline
void bindPipeline(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderPass2
void endRenderPass2(const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportSwizzleNV
void setViewportSwizzleNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportSwizzleNV *pViewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endVideoCodingKHR
void endVideoCodingKHR(const vk::VideoEndCodingInfoKHR &endCodingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDescriptorBufferOffsetsEXT
void setDescriptorBufferOffsetsEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const vk::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeMicromapsPropertiesEXT
void writeMicromapsPropertiesEXT(uint32_t micromapCount, const vk::MicromapEXT *pMicromaps, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCullModeEXT
void setCullModeEXT(vk::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage
void blitImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit *pRegions, vk::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilCompareMask
void setStencilCompareMask(vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWScalingNV
void setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV *pViewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMultiIndexedEXT
void drawMultiIndexedEXT(vk::StridedArrayProxy< const vk::MultiDrawIndexedInfoEXT > const &indexInfo, uint32_t instanceCount, uint32_t firstInstance, Optional< const int32_t > vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorWriteMaskEXT
void setColorWriteMaskEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorComponentFlags > const &colorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator<
bool operator<(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4303

vk::CommandBuffer::copyBuffer
void copyBuffer(vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportShadingRatePaletteNV
void setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV *pShadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderPass
void endRenderPass(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendEnableEXT
void setColorBlendEnableEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::Bool32 *pColorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceMarkerINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceMarkerINTEL(const vk::PerformanceMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::bindIndexBuffer2KHR
void bindIndexBuffer2KHR(vk::Buffer buffer, vk::DeviceSize offset, vk::DeviceSize size, vk::IndexType indexType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderPass2KHR
void endRenderPass2KHR(const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSetWithTemplateKHR
void pushDescriptorSetWithTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBuffer2KHR
void copyBuffer2KHR(const vk::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeTimestamp2KHR
void writeTimestamp2KHR(vk::PipelineStageFlags2 stage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::nextSubpass2KHR
void nextSubpass2KHR(const vk::SubpassBeginInfo *pSubpassBeginInfo, const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setShadingRateImageEnableNV
void setShadingRateImageEnableNV(vk::Bool32 shadingRateImageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilTestEnableEXT
void setStencilTestEnableEXT(vk::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBiasEnable
void setDepthBiasEnable(vk::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeAccelerationStructuresPropertiesKHR
void writeAccelerationStructuresPropertiesKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRendering
void beginRendering(const vk::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRenderPass2
void endRenderPass2(const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDescriptorBufferOffsets2EXT
void setDescriptorBufferOffsets2EXT(const vk::SetDescriptorBufferOffsetsInfoEXT &setDescriptorBufferOffsetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::traceRaysIndirect2KHR
void traceRaysIndirect2KHR(vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMultiIndexedEXT
void drawMultiIndexedEXT(uint32_t drawCount, const vk::MultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endQueryIndexedEXT
void endQueryIndexedEXT(vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resolveImage2
void resolveImage2(const vk::ResolveImageInfo2 &resolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewport
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSetKHR
void pushDescriptorSetKHR(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet *pDescriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pushDescriptorSetWithTemplateKHR
void pushDescriptorSetWithTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::endRendering
void endRendering(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resolveImage2KHR
void resolveImage2KHR(const vk::ResolveImageInfo2 &resolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass
void beginRenderPass(const vk::RenderPassBeginInfo &renderPassBegin, vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageModulationTableEnableNV
void setCoverageModulationTableEnableNV(vk::Bool32 coverageModulationTableEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator==
bool operator==(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4293

vk::CommandBuffer::setCoverageModulationTableNV
void setCoverageModulationTableNV(uint32_t coverageModulationTableCount, const float *pCoverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::executeGeneratedCommandsNV
void executeGeneratedCommandsNV(vk::Bool32 isPreprocessed, const vk::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilOp
void setStencilOp(vk::StencilFaceFlags faceMask, vk::StencilOp failOp, vk::StencilOp passOp, vk::StencilOp depthFailOp, vk::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorBlendEnableEXT
void setColorBlendEnableEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::Bool32 > const &colorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDiscardRectangleEXT
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, vk::ArrayProxy< const vk::Rect2D > const &discardRectangles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass2
void beginRenderPass2(const vk::RenderPassBeginInfo *pRenderPassBegin, const vk::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoverageToColorEnableNV
void setCoverageToColorEnableNV(vk::Bool32 coverageToColorEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBufferToImage2
void copyBufferToImage2(const vk::CopyBufferToImageInfo2 &copyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryToMicromapEXT
void copyMemoryToMicromapEXT(const vk::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resolveImage2KHR
void resolveImage2KHR(const vk::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setLineWidth
void setLineWidth(float lineWidth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoarseSampleOrderNV
void setCoarseSampleOrderNV(vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV *pCustomSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilTestEnable
void setStencilTestEnable(vk::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyImage
void copyImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setEvent2KHR
void setEvent2KHR(vk::Event event, const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndirectCountAMD
void drawIndirectCountAMD(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::decompressMemoryIndirectCountNV
void decompressMemoryIndirectCountNV(vk::DeviceAddress indirectCommandsAddress, vk::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::executeGeneratedCommandsNV
void executeGeneratedCommandsNV(vk::Bool32 isPreprocessed, const vk::GeneratedCommandsInfoNV &generatedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginRenderPass2KHR
void beginRenderPass2KHR(const vk::RenderPassBeginInfo &renderPassBegin, const vk::SubpassBeginInfo &subpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndirectByteCountEXT
void drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::cuLaunchKernelNVX
void cuLaunchKernelNVX(const vk::CuLaunchInfoNVX &launchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::executeCommands
void executeCommands(vk::ArrayProxy< const vk::CommandBuffer > const &commandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setSampleLocationsEXT
void setSampleLocationsEXT(const vk::SampleLocationsInfoEXT *pSampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeAccelerationStructuresPropertiesKHR
void writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const vk::AccelerationStructureKHR *pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::debugMarkerBeginEXT
void debugMarkerBeginEXT(const vk::DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6595

vk::CommandBuffer::drawMeshTasksNV
void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setFrontFace
void setFrontFace(vk::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::writeAccelerationStructuresPropertiesNV
void writeAccelerationStructuresPropertiesNV(vk::ArrayProxy< const vk::AccelerationStructureNV > const &accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorWriteEnableEXT
void setColorWriteEnableEXT(uint32_t attachmentCount, const vk::Bool32 *pColorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::blitImage2KHR
void blitImage2KHR(const vk::BlitImageInfo2 &blitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorBuffersEXT
void bindDescriptorBuffersEXT(uint32_t bufferCount, const vk::DescriptorBufferBindingInfoEXT *pBindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::updateBuffer
void updateBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::dispatchBaseKHR
void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resetQueryPool
void resetQueryPool(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents2
void waitEvents2(vk::ArrayProxy< const vk::Event > const &events, vk::ArrayProxy< const vk::DependencyInfo > const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::setCheckpointNV
void setCheckpointNV(CheckpointMarkerType const &checkpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyAccelerationStructureNV
void copyAccelerationStructureNV(vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeKHR mode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginQueryIndexedEXT
void beginQueryIndexedEXT(vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindShadersEXT
void bindShadersEXT(uint32_t stageCount, const vk::ShaderStageFlagBits *pStages, const vk::ShaderEXT *pShaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setExclusiveScissorNV
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, vk::ArrayProxy< const vk::Rect2D > const &exclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthWriteEnableEXT
void setDepthWriteEnableEXT(vk::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::nextSubpass2
void nextSubpass2(const vk::SubpassBeginInfo &subpassBeginInfo, const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::CommandBuffer
VULKAN_HPP_CONSTEXPR CommandBuffer()=default

vk::CommandBuffer::clearAttachments
void clearAttachments(vk::ArrayProxy< const vk::ClearAttachment > const &attachments, vk::ArrayProxy< const vk::ClearRect > const &rects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthBias
void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryToAccelerationStructureKHR
void copyMemoryToAccelerationStructureKHR(const vk::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawMeshTasksEXT
void drawMeshTasksEXT(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setEvent
void setEvent(vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setVertexInputEXT
void setVertexInputEXT(vk::ArrayProxy< const vk::VertexInputBindingDescription2EXT > const &vertexBindingDescriptions, vk::ArrayProxy< const vk::VertexInputAttributeDescription2EXT > const &vertexAttributeDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindShadersEXT
void bindShadersEXT(vk::ArrayProxy< const vk::ShaderStageFlagBits > const &stages, vk::ArrayProxy< const vk::ShaderEXT > const &shaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::bindInvocationMaskHUAWEI
void bindInvocationMaskHUAWEI(vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resetEvent
void resetEvent(vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructureNV
void buildAccelerationStructureNV(const vk::AccelerationStructureInfoNV &info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthCompareOpEXT
void setDepthCompareOpEXT(vk::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setViewportWithCount
void setViewportWithCount(vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::CType
VkCommandBuffer CType
Definition: vulkan_handles.hpp:4264

vk::CommandBuffer::resolveImage
void resolveImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setEvent2
void setEvent2(vk::Event event, const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setPerformanceOverrideINTEL
VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(const vk::PerformanceOverrideInfoINTEL *pOverrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setSampleLocationsEnableEXT
void setSampleLocationsEnableEXT(vk::Bool32 sampleLocationsEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMemoryToAccelerationStructureKHR
void copyMemoryToAccelerationStructureKHR(const vk::CopyMemoryToAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyBufferToImage2KHR
void copyBufferToImage2KHR(const vk::CopyBufferToImageInfo2 &copyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setRasterizationSamplesEXT
void setRasterizationSamplesEXT(vk::SampleCountFlagBits rasterizationSamples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDepthWriteEnable
void setDepthWriteEnable(vk::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier
void pipelineBarrier(vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setColorWriteEnableEXT
void setColorWriteEnableEXT(vk::ArrayProxy< const vk::Bool32 > const &colorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::pipelineBarrier2
void pipelineBarrier2(const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndexedIndirectCount
void drawIndexedIndirectCount(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindVertexBuffers2EXT
void bindVertexBuffers2EXT(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, const vk::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setFragmentShadingRateKHR
void setFragmentShadingRateKHR(const vk::Extent2D &fragmentSize, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setStencilReference
void setStencilReference(vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::bindDescriptorSets
void bindDescriptorSets(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, vk::ArrayProxy< const vk::DescriptorSet > const &descriptorSets, vk::ArrayProxy< const uint32_t > const &dynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setFrontFaceEXT
void setFrontFaceEXT(vk::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::dispatchIndirect
void dispatchIndirect(vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setDiscardRectangleModeEXT
void setDiscardRectangleModeEXT(vk::DiscardRectangleModeEXT discardRectangleMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::beginQuery
void beginQuery(vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::resetEvent2KHR
void resetEvent2KHR(vk::Event event, vk::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::updateBuffer
void updateBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::ArrayProxy< const DataType > const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setSampleMaskEXT
void setSampleMaskEXT(vk::SampleCountFlagBits samples, vk::ArrayProxy< const vk::SampleMask > const &sampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::CommandBuffer::traceRaysIndirectKHR
void traceRaysIndirectKHR(const vk::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &missShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &hitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &callableShaderBindingTable, vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMicromapToMemoryEXT
void copyMicromapToMemoryEXT(const vk::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::drawIndirectCount
void drawIndirectCount(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyMicromapToMemoryEXT
void copyMicromapToMemoryEXT(const vk::CopyMicromapToMemoryInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildAccelerationStructuresKHR
void buildAccelerationStructuresKHR(uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::dispatch
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::setCoarseSampleOrderNV
void setCoarseSampleOrderNV(vk::CoarseSampleOrderTypeNV sampleOrderType, vk::ArrayProxy< const vk::CoarseSampleOrderCustomNV > const &customSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::clearColorImage
void clearColorImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue *pColor, uint32_t rangeCount, const vk::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::buildMicromapsEXT
void buildMicromapsEXT(vk::ArrayProxy< const vk::MicromapBuildInfoEXT > const &infos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::waitEvents
void waitEvents(uint32_t eventCount, const vk::Event *pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::copyAccelerationStructureToMemoryKHR
void copyAccelerationStructureToMemoryKHR(const vk::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandBuffer::reset
ResultValueType< void >::type reset(vk::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::CommandBuffer::setSampleLocationsEXT
void setSampleLocationsEXT(const vk::SampleLocationsInfoEXT &sampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::CommandPool
Definition: vulkan_handles.hpp:7054

vk::CommandPool::NativeType
VkCommandPool NativeType
Definition: vulkan_handles.hpp:7057

vk::CommandPool::CommandPool
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7068

vk::CommandPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7113

vk::CommandPool::CommandPool
VULKAN_HPP_CONSTEXPR CommandPool()=default

vk::CommandPool::operator!=
bool operator!=(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7092

vk::CommandPool::operator=
CommandPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7078

vk::CommandPool::CommandPool
VULKAN_HPP_CONSTEXPR CommandPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7066

vk::CommandPool::CType
VkCommandPool CType
Definition: vulkan_handles.hpp:7056

vk::CommandPool::operator<
bool operator<(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7097

vk::CommandPool::operator==
bool operator==(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7087

vk::CuFunctionNVX
Definition: vulkan_handles.hpp:7228

vk::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7242

vk::CuFunctionNVX::operator!=
bool operator!=(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7266

vk::CuFunctionNVX::operator<
bool operator<(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7271

vk::CuFunctionNVX::NativeType
VkCuFunctionNVX NativeType
Definition: vulkan_handles.hpp:7231

vk::CuFunctionNVX::CType
VkCuFunctionNVX CType
Definition: vulkan_handles.hpp:7230

vk::CuFunctionNVX::operator=
CuFunctionNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7252

vk::CuFunctionNVX::operator==
bool operator==(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7261

vk::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_CONSTEXPR CuFunctionNVX()=default

vk::CuFunctionNVX::CuFunctionNVX
VULKAN_HPP_CONSTEXPR CuFunctionNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7240

vk::CuFunctionNVX::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7287

vk::CuModuleNVX
Definition: vulkan_handles.hpp:7315

vk::CuModuleNVX::CuModuleNVX
VULKAN_HPP_CONSTEXPR CuModuleNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7327

vk::CuModuleNVX::CType
VkCuModuleNVX CType
Definition: vulkan_handles.hpp:7317

vk::CuModuleNVX::CuModuleNVX
VULKAN_HPP_CONSTEXPR CuModuleNVX()=default

vk::CuModuleNVX::NativeType
VkCuModuleNVX NativeType
Definition: vulkan_handles.hpp:7318

vk::CuModuleNVX::operator=
CuModuleNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7339

vk::CuModuleNVX::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7374

vk::CuModuleNVX::CuModuleNVX
VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7329

vk::CuModuleNVX::operator==
bool operator==(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7348

vk::CuModuleNVX::operator!=
bool operator!=(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7353

vk::CuModuleNVX::operator<
bool operator<(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7358

vk::DebugReportCallbackEXT
Definition: vulkan_handles.hpp:2442

vk::DebugReportCallbackEXT::CType
VkDebugReportCallbackEXT CType
Definition: vulkan_handles.hpp:2444

vk::DebugReportCallbackEXT::operator==
bool operator==(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2478

vk::DebugReportCallbackEXT::operator<
bool operator<(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2488

vk::DebugReportCallbackEXT::operator=
DebugReportCallbackEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2469

vk::DebugReportCallbackEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2504

vk::DebugReportCallbackEXT::NativeType
VkDebugReportCallbackEXT NativeType
Definition: vulkan_handles.hpp:2445

vk::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()=default

vk::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2454

vk::DebugReportCallbackEXT::operator!=
bool operator!=(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2483

vk::DebugReportCallbackEXT::DebugReportCallbackEXT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2456

vk::DebugUtilsMessengerEXT
Definition: vulkan_handles.hpp:2532

vk::DebugUtilsMessengerEXT::operator<
bool operator<(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2578

vk::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2544

vk::DebugUtilsMessengerEXT::operator=
DebugUtilsMessengerEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2559

vk::DebugUtilsMessengerEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2594

vk::DebugUtilsMessengerEXT::operator!=
bool operator!=(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2573

vk::DebugUtilsMessengerEXT::NativeType
VkDebugUtilsMessengerEXT NativeType
Definition: vulkan_handles.hpp:2535

vk::DebugUtilsMessengerEXT::CType
VkDebugUtilsMessengerEXT CType
Definition: vulkan_handles.hpp:2534

vk::DebugUtilsMessengerEXT::operator==
bool operator==(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2568

vk::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()=default

vk::DebugUtilsMessengerEXT::DebugUtilsMessengerEXT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2546

vk::DeferredOperationKHR
Definition: vulkan_handles.hpp:6791

vk::DeferredOperationKHR::operator==
bool operator==(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6827

vk::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_CONSTEXPR DeferredOperationKHR()=default

vk::DeferredOperationKHR::operator<
bool operator<(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6837

vk::DeferredOperationKHR::CType
VkDeferredOperationKHR CType
Definition: vulkan_handles.hpp:6793

vk::DeferredOperationKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6853

vk::DeferredOperationKHR::operator=
DeferredOperationKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6818

vk::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6805

vk::DeferredOperationKHR::NativeType
VkDeferredOperationKHR NativeType
Definition: vulkan_handles.hpp:6794

vk::DeferredOperationKHR::operator!=
bool operator!=(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6832

vk::DeferredOperationKHR::DeferredOperationKHR
VULKAN_HPP_CONSTEXPR DeferredOperationKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6803

vk::DescriptorPool
Definition: vulkan_handles.hpp:7580

vk::DescriptorPool::operator=
DescriptorPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7604

vk::DescriptorPool::DescriptorPool
VULKAN_HPP_CONSTEXPR DescriptorPool()=default

vk::DescriptorPool::DescriptorPool
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7594

vk::DescriptorPool::NativeType
VkDescriptorPool NativeType
Definition: vulkan_handles.hpp:7583

vk::DescriptorPool::operator<
bool operator<(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7623

vk::DescriptorPool::DescriptorPool
VULKAN_HPP_CONSTEXPR DescriptorPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7592

vk::DescriptorPool::operator==
bool operator==(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7613

vk::DescriptorPool::CType
VkDescriptorPool CType
Definition: vulkan_handles.hpp:7582

vk::DescriptorPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7639

vk::DescriptorPool::operator!=
bool operator!=(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7618

vk::DescriptorSetLayout
Definition: vulkan_handles.hpp:7667

vk::DescriptorSetLayout::operator=
DescriptorSetLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7694

vk::DescriptorSetLayout::operator==
bool operator==(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7703

vk::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()=default

vk::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7681

vk::DescriptorSetLayout::DescriptorSetLayout
VULKAN_HPP_CONSTEXPR DescriptorSetLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7679

vk::DescriptorSetLayout::operator!=
bool operator!=(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7708

vk::DescriptorSetLayout::CType
VkDescriptorSetLayout CType
Definition: vulkan_handles.hpp:7669

vk::DescriptorSetLayout::NativeType
VkDescriptorSetLayout NativeType
Definition: vulkan_handles.hpp:7670

vk::DescriptorSetLayout::operator<
bool operator<(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7713

vk::DescriptorSetLayout::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7729

vk::DescriptorSet
Definition: vulkan_handles.hpp:3309

vk::DescriptorSet::CType
VkDescriptorSet CType
Definition: vulkan_handles.hpp:3311

vk::DescriptorSet::operator==
bool operator==(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3342

vk::DescriptorSet::operator<
bool operator<(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3352

vk::DescriptorSet::DescriptorSet
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3323

vk::DescriptorSet::DescriptorSet
VULKAN_HPP_CONSTEXPR DescriptorSet(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3321

vk::DescriptorSet::NativeType
VkDescriptorSet NativeType
Definition: vulkan_handles.hpp:3312

vk::DescriptorSet::DescriptorSet
VULKAN_HPP_CONSTEXPR DescriptorSet()=default

vk::DescriptorSet::operator!=
bool operator!=(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3347

vk::DescriptorSet::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3368

vk::DescriptorSet::operator=
DescriptorSet & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3333

vk::DescriptorUpdateTemplate
Definition: vulkan_handles.hpp:3912

vk::DescriptorUpdateTemplate::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3974

vk::DescriptorUpdateTemplate::operator==
bool operator==(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3948

vk::DescriptorUpdateTemplate::NativeType
VkDescriptorUpdateTemplate NativeType
Definition: vulkan_handles.hpp:3915

vk::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3926

vk::DescriptorUpdateTemplate::operator!=
bool operator!=(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3953

vk::DescriptorUpdateTemplate::operator=
DescriptorUpdateTemplate & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3939

vk::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3924

vk::DescriptorUpdateTemplate::CType
VkDescriptorUpdateTemplate CType
Definition: vulkan_handles.hpp:3914

vk::DescriptorUpdateTemplate::operator<
bool operator<(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3958

vk::DescriptorUpdateTemplate::DescriptorUpdateTemplate
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()=default

vk::DeviceMemory
Definition: vulkan_handles.hpp:6623

vk::DeviceMemory::NativeType
VkDeviceMemory NativeType
Definition: vulkan_handles.hpp:6626

vk::DeviceMemory::CType
VkDeviceMemory CType
Definition: vulkan_handles.hpp:6625

vk::DeviceMemory::operator<
bool operator<(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6666

vk::DeviceMemory::DeviceMemory
VULKAN_HPP_CONSTEXPR DeviceMemory()=default

vk::DeviceMemory::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6682

vk::DeviceMemory::DeviceMemory
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6637

vk::DeviceMemory::operator!=
bool operator!=(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6661

vk::DeviceMemory::operator=
DeviceMemory & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6647

vk::DeviceMemory::operator==
bool operator==(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6656

vk::DeviceMemory::DeviceMemory
VULKAN_HPP_CONSTEXPR DeviceMemory(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6635

vk::Device
Definition: vulkan_handles.hpp:8782

vk::Device::releaseSwapchainImagesEXT
VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT(const vk::ReleaseSwapchainImagesInfoEXT *pReleaseInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createFence
VULKAN_HPP_NODISCARD Result createFence(const vk::FenceCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getEncodedVideoSessionParametersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::setHdrMetadataEXT
void setHdrMetadataEXT(vk::ArrayProxy< const vk::SwapchainKHR > const &swapchains, vk::ArrayProxy< const vk::HdrMetadataEXT > const &metadata, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::Device::destroyCuModuleNVX
void destroyCuModuleNVX(vk::CuModuleNVX module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::IndirectCommandsLayoutNV indirectCommandsLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPrivateDataSlotEXT
void destroyPrivateDataSlotEXT(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createImageUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Image, Dispatch > >::type createImageUnique(const vk::ImageCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyPipelineLayout
void destroyPipelineLayout(vk::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineIndirectAddressNV
DeviceAddress getPipelineIndirectAddressNV(const vk::PipelineIndirectDeviceAddressInfoNV *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyAccelerationStructureNV
void destroyAccelerationStructureNV(vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutHostMappingInfoVALVE
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE(const vk::DescriptorSetBindingReferenceVALVE &bindingReference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::signalSemaphore
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type signalSemaphore(const vk::SemaphoreSignalInfo &signalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirements2
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShaderModuleUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ShaderModule, Dispatch > >::type createShaderModuleUnique(const vk::ShaderModuleCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyFramebuffer
void destroyFramebuffer(vk::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::debugMarkerSetObjectNameEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type debugMarkerSetObjectNameEXT(const vk::DebugMarkerObjectNameInfoEXT &nameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyCommandPool
void destroyCommandPool(vk::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShadersEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::ShaderEXT, Dispatch >, ShaderEXTAllocator > >::type createShadersEXTUnique(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, ShaderEXTAllocator &shaderEXTAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDeferredOperationMaxConcurrencyKHR
uint32_t getDeferredOperationMaxConcurrencyKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getEncodedVideoSessionParametersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createGraphicsPipelinesUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createGraphicsPipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createEvent
VULKAN_HPP_NODISCARD ResultValueType< vk::Event >::type createEvent(const vk::EventCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getCalibratedTimestampEXT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampEXT(const vk::CalibratedTimestampInfoKHR &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getCalibratedTimestampKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampKHR(const vk::CalibratedTimestampInfoKHR &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureAddressKHR
DeviceAddress getAccelerationStructureAddressKHR(const vk::AccelerationStructureDeviceAddressInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyAccelerationStructureNV
void destroyAccelerationStructureNV(vk::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createValidationCacheEXT
VULKAN_HPP_NODISCARD Result createValidationCacheEXT(const vk::ValidationCacheCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ValidationCacheEXT *pValidationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(const vk::BufferCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelineKHR
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createRayTracingPipelineKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorSetLayoutSizeEXT
void getDescriptorSetLayoutSizeEXT(vk::DescriptorSetLayout layout, vk::DeviceSize *pLayoutSizeInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirements2KHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getFaultInfoEXT
VULKAN_HPP_NODISCARD ResultValue< std::pair< vk::DeviceFaultCountsEXT, vk::DeviceFaultInfoEXT > > getFaultInfoEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createCuFunctionNVX
VULKAN_HPP_NODISCARD Result createCuFunctionNVX(const vk::CuFunctionCreateInfoNVX *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CuFunctionNVX *pFunction, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::writeAccelerationStructuresPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type writeAccelerationStructuresPropertiesKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, size_t dataSize, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyImage
void destroyImage(vk::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::importFenceFdKHR
VULKAN_HPP_NODISCARD Result importFenceFdKHR(const vk::ImportFenceFdInfoKHR *pImportFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getCalibratedTimestampsEXT
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(uint32_t timestampCount, const vk::CalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createMicromapEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::MicromapEXT, Dispatch > >::type createMicromapEXTUnique(const vk::MicromapCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferOpaqueCaptureAddressKHR
uint64_t getBufferOpaqueCaptureAddressKHR(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements
void getImageMemoryRequirements(vk::Image image, vk::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateDescriptorSets
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DescriptorSet, DescriptorSetAllocator > >::type allocateDescriptorSets(const vk::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateMemoryUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DeviceMemory, Dispatch > >::type allocateMemoryUnique(const vk::MemoryAllocateInfo &allocateInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPrivateData
VULKAN_HPP_NODISCARD uint64_t getPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyOpticalFlowSessionNV
void destroyOpticalFlowSessionNV(vk::OpticalFlowSessionNV session, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShaderModule
VULKAN_HPP_NODISCARD Result createShaderModule(const vk::ShaderModuleCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ShaderModule *pShaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setMemoryPriorityEXT
void setMemoryPriorityEXT(vk::DeviceMemory memory, float priority, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Buffer buffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSampler
VULKAN_HPP_NODISCARD ResultValueType< vk::Sampler >::type createSampler(const vk::SamplerCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createFramebufferUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Framebuffer, Dispatch > >::type createFramebufferUnique(const vk::FramebufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferMemoryRequirements2KHR
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPrivateDataSlotEXT
void destroyPrivateDataSlotEXT(vk::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPrivateDataSlot
VULKAN_HPP_NODISCARD ResultValueType< vk::PrivateDataSlot >::type createPrivateDataSlot(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPipelineLayout
VULKAN_HPP_NODISCARD Result createPipelineLayout(const vk::PipelineLayoutCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PipelineLayout *pPipelineLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getCalibratedTimestampsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsKHR(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Uint64_tAllocator &uint64_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageViewAddressNVX
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX(vk::ImageView imageView, vk::ImageViewAddressPropertiesNVX *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryCommitment
void getMemoryCommitment(vk::DeviceMemory memory, vk::DeviceSize *pCommittedMemoryInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateMemory
VULKAN_HPP_NODISCARD Result allocateMemory(const vk::MemoryAllocateInfo *pAllocateInfo, const vk::AllocationCallbacks *pAllocator, vk::DeviceMemory *pMemory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mapMemory
VULKAN_HPP_NODISCARD ResultValueType< void * >::type mapMemory(vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::resetQueryPoolEXT
void resetQueryPoolEXT(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRefreshCycleDurationGOOGLE
VULKAN_HPP_NODISCARD ResultValueType< vk::RefreshCycleDurationGOOGLE >::type getRefreshCycleDurationGOOGLE(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::waitForPresentKHR
VULKAN_HPP_NODISCARD vk::Result waitForPresentKHR(vk::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorSetLayout
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorSetLayout >::type createDescriptorSetLayout(const vk::DescriptorSetLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getCalibratedTimestampsKHR
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR(uint32_t timestampCount, const vk::CalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyEvent
void destroyEvent(vk::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryFdKHR
VULKAN_HPP_NODISCARD Result getMemoryFdKHR(const vk::MemoryGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Event event, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquireNextImage2KHR
VULKAN_HPP_NODISCARD ResultValue< uint32_t > acquireNextImage2KHR(const vk::AcquireNextImageInfoKHR &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorUpdateTemplateKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorUpdateTemplate >::type createDescriptorUpdateTemplateKHR(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::setLocalDimmingAMD
void setLocalDimmingAMD(vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMicromapBuildSizesEXT
VULKAN_HPP_NODISCARD vk::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT(vk::AccelerationStructureBuildTypeKHR buildType, const vk::MicromapBuildInfoEXT &buildInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::importSemaphoreFdKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type importSemaphoreFdKHR(const vk::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::unmapMemory2KHR
void unmapMemory2KHR(const vk::MemoryUnmapInfoKHR &memoryUnmapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutSupport
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SwapchainKHR, SwapchainKHRAllocator > >::type createSharedSwapchainsKHR(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyDescriptorPool
void destroyDescriptorPool(vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPrivateDataSlotEXT
VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT(const vk::PrivateDataSlotCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getShaderBinaryDataEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderBinaryDataEXT(vk::ShaderEXT shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::debugMarkerSetObjectTagEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type debugMarkerSetObjectTagEXT(const vk::DebugMarkerObjectTagInfoEXT &tagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindImageMemory2
VULKAN_HPP_NODISCARD Result bindImageMemory2(uint32_t bindInfoCount, const vk::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::displayPowerControlEXT
ResultValueType< void >::type displayPowerControlEXT(vk::DisplayKHR display, const vk::DisplayPowerInfoEXT &displayPowerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSamplerYcbcrConversionKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionKHRUnique(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createGraphicsPipelineUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createGraphicsPipelineUnique(vk::PipelineCache pipelineCache, const vk::GraphicsPipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getShaderModuleCreateInfoIdentifierEXT
VULKAN_HPP_NODISCARD vk::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT(const vk::ShaderModuleCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDeferredOperationKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DeferredOperationKHR >::type createDeferredOperationKHR(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::AccelerationStructureNV accelerationStructure, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquireNextImage2KHR
VULKAN_HPP_NODISCARD Result acquireNextImage2KHR(const vk::AcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createBufferViewUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::BufferView, Dispatch > >::type createBufferViewUnique(const vk::BufferViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getCalibratedTimestampsEXT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsEXT(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Uint64_tAllocator &uint64_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createAccelerationStructureNV
VULKAN_HPP_NODISCARD ResultValueType< vk::AccelerationStructureNV >::type createAccelerationStructureNV(const vk::AccelerationStructureCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createComputePipelinesUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createComputePipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroySemaphore
void destroySemaphore(vk::Semaphore semaphore, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPrivateDataEXT
VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setDebugUtilsObjectTagEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setDebugUtilsObjectTagEXT(const vk::DebugUtilsObjectTagInfoEXT &tagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorSetHostMappingVALVE
VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE(vk::DescriptorSet descriptorSet, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getLatencyTimingsNV
VULKAN_HPP_NODISCARD vk::GetLatencyMarkerInfoNV getLatencyTimingsNV(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyEvent
void destroyEvent(vk::Event event, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryFdPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::MemoryFdPropertiesKHR >::type getMemoryFdPropertiesKHR(vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSemaphoreCounterValueKHR
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(vk::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyImageToImageEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyImageToImageEXT(const vk::CopyImageToImageInfoEXT &copyImageToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyDeferredOperationKHR
void destroyDeferredOperationKHR(vk::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyAccelerationStructureKHR
void destroyAccelerationStructureKHR(vk::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGroupPresentCapabilitiesKHR
VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(vk::DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getShaderModuleCreateInfoIdentifierEXT
void getShaderModuleCreateInfoIdentifierEXT(const vk::ShaderModuleCreateInfo *pCreateInfo, vk::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyMicromapToMemoryEXT
VULKAN_HPP_NODISCARD vk::Result copyMicromapToMemoryEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapToMemoryInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::initializePerformanceApiINTEL
VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(const vk::InitializePerformanceApiInfoINTEL *pInitializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureMemoryRequirementsNV
void getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV *pInfo, vk::MemoryRequirements2KHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Image image, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyValidationCacheEXT
void destroyValidationCacheEXT(vk::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirementsKHR
void getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createCuFunctionNVXUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CuFunctionNVX, Dispatch > >::type createCuFunctionNVXUnique(const vk::CuFunctionCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRenderAreaGranularity
void getRenderAreaGranularity(vk::RenderPass renderPass, vk::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMicromapBuildSizesEXT
void getMicromapBuildSizesEXT(vk::AccelerationStructureBuildTypeKHR buildType, const vk::MicromapBuildInfoEXT *pBuildInfo, vk::MicromapBuildSizesInfoEXT *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutHostMappingInfoVALVE
void getDescriptorSetLayoutHostMappingInfoVALVE(const vk::DescriptorSetBindingReferenceVALVE *pBindingReference, vk::DescriptorSetLayoutHostMappingInfoVALVE *pHostMapping, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShaderEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ShaderEXT, Dispatch > >::type createShaderEXTUnique(const vk::ShaderCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::BufferView bufferView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::registerEventEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type registerEventEXTUnique(const vk::DeviceEventInfoEXT &deviceEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::buildMicromapsEXT
VULKAN_HPP_NODISCARD Result buildMicromapsEXT(vk::DeferredOperationKHR deferredOperation, uint32_t infoCount, const vk::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineExecutableInternalRepresentationsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator > >::type getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindBufferMemory2
VULKAN_HPP_NODISCARD Result bindBufferMemory2(uint32_t bindInfoCount, const vk::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SwapchainKHR, SwapchainKHRAllocator > >::type createSharedSwapchainsKHR(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getShaderModuleIdentifierEXT
void getShaderModuleIdentifierEXT(vk::ShaderModule shaderModule, vk::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPipelineCache
VULKAN_HPP_NODISCARD ResultValueType< vk::PipelineCache >::type createPipelineCache(const vk::PipelineCacheCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::unmapMemory
void unmapMemory(vk::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createOpticalFlowSessionNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::OpticalFlowSessionNV, Dispatch > >::type createOpticalFlowSessionNVUnique(const vk::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutSupport
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::updateDescriptorSetWithTemplate
void updateDescriptorSetWithTemplate(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13892

vk::Device::getPipelineIndirectMemoryRequirementsNV
void getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo *pCreateInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::latencySleepNV
VULKAN_HPP_NODISCARD Result latencySleepNV(vk::SwapchainKHR swapchain, const vk::LatencySleepInfoNV *pSleepInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::trimCommandPool
void trimCommandPool(vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySamplerYcbcrConversionKHR
void destroySamplerYcbcrConversionKHR(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureHandleNV
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::CuFunctionNVX function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getShaderInfoAMD
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyShaderModule
void destroyShaderModule(vk::ShaderModule shaderModule, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSamplerYcbcrConversionKHR
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(const vk::SamplerYcbcrConversionCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout2KHR
void getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR *pSubresource, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mergePipelineCaches
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type mergePipelineCaches(vk::PipelineCache dstCache, vk::ArrayProxy< const vk::PipelineCache > const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyImageToImageEXT
VULKAN_HPP_NODISCARD Result copyImageToImageEXT(const vk::CopyImageToImageInfoEXT *pCopyImageToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureAddressKHR
vk::DeviceAddress getAccelerationStructureAddressKHR(const vk::AccelerationStructureDeviceAddressInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::transitionImageLayoutEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type transitionImageLayoutEXT(vk::ArrayProxy< const vk::HostImageLayoutTransitionInfoEXT > const &transitions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRayTracingPipelinesNV
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirementsKHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::Device
Device(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8796

vk::Device::getGroupSurfacePresentModesKHR
VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR *pModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::freeCommandBuffers
void freeCommandBuffers(vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::RenderPass renderPass, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getValidationCacheDataEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyImageView
void destroyImageView(vk::ImageView imageView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyMemoryToImageEXT
VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT(const vk::CopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::resetCommandPool
ResultValueType< void >::type resetCommandPool(vk::CommandPool commandPool, vk::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryCommitment
VULKAN_HPP_NODISCARD vk::DeviceSize getMemoryCommitment(vk::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::writeMicromapsPropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type writeMicromapsPropertiesEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, size_t dataSize, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createBufferView
VULKAN_HPP_NODISCARD Result createBufferView(const vk::BufferViewCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::BufferView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createCuModuleNVX
VULKAN_HPP_NODISCARD Result createCuModuleNVX(const vk::CuModuleCreateInfoNVX *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CuModuleNVX *pModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements2
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setDebugUtilsObjectNameEXT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(const vk::DebugUtilsObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyMemoryToMicromapEXT
VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelineNVUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createRayTracingPipelineNVUnique(vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getQueryPoolResults
VULKAN_HPP_NODISCARD Result getQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::NativeType
VkDevice NativeType
Definition: vulkan_handles.hpp:8785

vk::Device::destroyVideoSessionParametersKHR
void destroyVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createComputePipelinesUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createComputePipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI
VULKAN_HPP_NODISCARD ResultValue< vk::Extent2D > getSubpassShadingMaxWorkgroupSizeHUAWEI(vk::RenderPass renderpass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPipelineLayout
VULKAN_HPP_NODISCARD ResultValueType< vk::PipelineLayout >::type createPipelineLayout(const vk::PipelineLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyMicromapEXT
void destroyMicromapEXT(vk::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::updateDescriptorSetWithTemplateKHR
void updateDescriptorSetWithTemplateKHR(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setEvent
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setEvent(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyPipelineCache
void destroyPipelineCache(vk::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyValidationCacheEXT
void destroyValidationCacheEXT(vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getShaderInfoAMD
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGroupSurfacePresentModesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceGroupPresentModeFlagsKHR >::type getGroupSurfacePresentModesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::writeAccelerationStructuresPropertiesKHR
VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const vk::AccelerationStructureKHR *pAccelerationStructures, vk::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::initializePerformanceApiINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type initializePerformanceApiINTEL(const vk::InitializePerformanceApiInfoINTEL &initializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirementsKHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createFenceUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type createFenceUnique(const vk::FenceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createBufferView
VULKAN_HPP_NODISCARD ResultValueType< vk::BufferView >::type createBufferView(const vk::BufferViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferAddressEXT
DeviceAddress getBufferAddressEXT(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGroupPeerMemoryFeaturesKHR
void getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyAccelerationStructureToMemoryKHR
VULKAN_HPP_NODISCARD vk::Result copyAccelerationStructureToMemoryKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureToMemoryInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createVideoSessionParametersKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoSessionParametersKHR >::type createVideoSessionParametersKHR(const vk::VideoSessionParametersCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineExecutableStatisticsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator > >::type getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, PipelineExecutableStatisticKHRAllocator &pipelineExecutableStatisticKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineExecutableStatisticsKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, vk::PipelineExecutableStatisticKHR *pStatistics, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Buffer buffer, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorUpdateTemplateKHR
void destroyDescriptorUpdateTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createAccelerationStructureNV
VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(const vk::AccelerationStructureCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::AccelerationStructureNV *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::waitSemaphores
VULKAN_HPP_NODISCARD vk::Result waitSemaphores(const vk::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindOpticalFlowSessionImageNV
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindOpticalFlowSessionImageNV(vk::OpticalFlowSessionNV session, vk::OpticalFlowSessionBindingPointNV bindingPoint, vk::ImageView view, vk::ImageLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::ImageView imageView, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createGraphicsPipeline
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createGraphicsPipeline(vk::PipelineCache pipelineCache, const vk::GraphicsPipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::ShaderEXT shader, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::updateDescriptorSets
void updateDescriptorSets(vk::ArrayProxy< const vk::WriteDescriptorSet > const &descriptorWrites, vk::ArrayProxy< const vk::CopyDescriptorSet > const &descriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorUpdateTemplateKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateKHRUnique(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferAddressKHR
DeviceAddress getBufferAddressKHR(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageViewOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT(const vk::ImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSemaphoreFdKHR
VULKAN_HPP_NODISCARD ResultValueType< int >::type getSemaphoreFdKHR(const vk::SemaphoreGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::freeMemory
void freeMemory(vk::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateDescriptorSetsUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::DescriptorSet, Dispatch >, DescriptorSetAllocator > >::type allocateDescriptorSetsUnique(const vk::DescriptorSetAllocateInfo &allocateInfo, DescriptorSetAllocator &descriptorSetAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorUpdateTemplate
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorUpdateTemplate >::type createDescriptorUpdateTemplate(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorPool
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorPool >::type createDescriptorPool(const vk::DescriptorPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyCommandPool
void destroyCommandPool(vk::CommandPool commandPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::updateDescriptorSets
void updateDescriptorSets(uint32_t descriptorWriteCount, const vk::WriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet *pDescriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSamplerUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Sampler, Dispatch > >::type createSamplerUnique(const vk::SamplerCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::CuModuleNVX module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyMemoryToMicromapEXT
VULKAN_HPP_NODISCARD vk::Result copyMemoryToMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSamplerOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getSamplerOpaqueCaptureDescriptorDataEXT(const vk::SamplerCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureHandleNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::acquireProfilingLockKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type acquireProfilingLockKHR(const vk::AcquireProfilingLockInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPrivateDataSlot
VULKAN_HPP_NODISCARD Result createPrivateDataSlot(const vk::PrivateDataSlotCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMicromapCompatibilityEXT
void getMicromapCompatibilityEXT(const vk::MicromapVersionInfoEXT *pVersionInfo, vk::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createFramebuffer
VULKAN_HPP_NODISCARD ResultValueType< vk::Framebuffer >::type createFramebuffer(const vk::FramebufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createCuModuleNVXUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CuModuleNVX, Dispatch > >::type createCuModuleNVXUnique(const vk::CuModuleCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorEXT
VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT(const vk::DescriptorGetInfoEXT &descriptorInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyShaderEXT
void destroyShaderEXT(vk::ShaderEXT shader, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelineKHRUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createRayTracingPipelineKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSubresourceLayout2EXT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::writeAccelerationStructuresPropertyKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeAccelerationStructuresPropertyKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::invalidateMappedMemoryRanges
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type invalidateMappedMemoryRanges(vk::ArrayProxy< const vk::MappedMemoryRange > const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::registerDisplayEventEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type registerDisplayEventEXT(vk::DisplayKHR display, const vk::DisplayEventInfoEXT &displayEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::acquireNextImageKHR
VULKAN_HPP_NODISCARD ResultValue< uint32_t > acquireNextImageKHR(vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::registerDisplayEventEXT
VULKAN_HPP_NODISCARD Result registerDisplayEventEXT(vk::DisplayKHR display, const vk::DisplayEventInfoEXT *pDisplayEventInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getQueue2
void getQueue2(const vk::DeviceQueueInfo2 *pQueueInfo, vk::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setLatencyMarkerNV
void setLatencyMarkerNV(vk::SwapchainKHR swapchain, const vk::SetLatencyMarkerInfoNV *pLatencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mapMemory
VULKAN_HPP_NODISCARD Result mapMemory(vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setLatencySleepModeNV
ResultValueType< void >::type setLatencySleepModeNV(vk::SwapchainKHR swapchain, const vk::LatencySleepModeInfoNV &sleepModeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirements2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyCuFunctionNVX
void destroyCuFunctionNVX(vk::CuFunctionNVX function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createComputePipelines
VULKAN_HPP_NODISCARD Result createComputePipelines(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements2KHR
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::operator=
Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8798

vk::Device::getImageSparseMemoryRequirements
void getImageSparseMemoryRequirements(vk::Image image, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyVideoSessionKHR
void destroyVideoSessionKHR(vk::VideoSessionKHR videoSession, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::ValidationCacheEXT validationCache, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPrivateDataSlotUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotUnique(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::debugMarkerSetObjectNameEXT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(const vk::DebugMarkerObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainsKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::SwapchainKHR, Dispatch >, SwapchainKHRAllocator > >::type createSharedSwapchainsKHRUnique(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRayTracingShaderGroupHandleNV
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRayTracingShaderGroupHandlesNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingShaderGroupHandlesNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRenderPassUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPassUnique(const vk::RenderPassCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createEventUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Event, Dispatch > >::type createEventUnique(const vk::EventCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::buildAccelerationStructuresKHR
VULKAN_HPP_NODISCARD vk::Result buildAccelerationStructuresKHR(vk::DeferredOperationKHR deferredOperation, vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::AccelerationStructureBuildRangeInfoKHR *const > const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyMicromapEXT
VULKAN_HPP_NODISCARD vk::Result copyMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroySamplerYcbcrConversionKHR
void destroySamplerYcbcrConversionKHR(vk::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPipelineCache
void destroyPipelineCache(vk::PipelineCache pipelineCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRefreshCycleDurationGOOGLE
VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE *pDisplayTimingProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createImageView
VULKAN_HPP_NODISCARD Result createImageView(const vk::ImageViewCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ImageView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSemaphoreCounterValue
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSemaphoreCounterValue(vk::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createIndirectCommandsLayoutNV
VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(const vk::IndirectCommandsLayoutCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::IndirectCommandsLayoutNV *pIndirectCommandsLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::ShaderModule shaderModule, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getProcAddr
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureCompatibilityKHR
void getAccelerationStructureCompatibilityKHR(const vk::AccelerationStructureVersionInfoKHR *pVersionInfo, vk::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Pipeline pipeline, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::invalidateMappedMemoryRanges
VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(uint32_t memoryRangeCount, const vk::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRayTracingShaderGroupHandlesNV
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSemaphoreCounterValue
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue(vk::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGroupPeerMemoryFeaturesKHR
VULKAN_HPP_NODISCARD vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::trimCommandPoolKHR
void trimCommandPoolKHR(vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::flushMappedMemoryRanges
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type flushMappedMemoryRanges(vk::ArrayProxy< const vk::MappedMemoryRange > const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::registerEventEXT
VULKAN_HPP_NODISCARD Result registerEventEXT(const vk::DeviceEventInfoEXT *pDeviceEventInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::MicromapEXT micromap, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyVideoSessionParametersKHR
void destroyVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPastPresentationTimingGOOGLE
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator > >::type getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::SwapchainKHR swapchain, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSamplerYcbcrConversion
VULKAN_HPP_NODISCARD ResultValueType< vk::SamplerYcbcrConversion >::type createSamplerYcbcrConversion(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyMicromapToMemoryEXT
VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineCacheData
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getPipelineCacheData(vk::PipelineCache pipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindBufferMemory
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory(vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSemaphoreUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Semaphore, Dispatch > >::type createSemaphoreUnique(const vk::SemaphoreCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getQueue
VULKAN_HPP_NODISCARD vk::Queue getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::operator<
bool operator<(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8823

vk::Device::createRenderPass2KHR
VULKAN_HPP_NODISCARD Result createRenderPass2KHR(const vk::RenderPassCreateInfo2 *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindAccelerationStructureMemoryNV
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindAccelerationStructureMemoryNV(vk::ArrayProxy< const vk::BindAccelerationStructureMemoryInfoNV > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyCuModuleNVX
void destroyCuModuleNVX(vk::CuModuleNVX module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Semaphore semaphore, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::waitForFences
VULKAN_HPP_NODISCARD Result waitForFences(uint32_t fenceCount, const vk::Fence *pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createGraphicsPipelines
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createGraphicsPipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::buildAccelerationStructuresKHR
VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(vk::DeferredOperationKHR deferredOperation, uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyAccelerationStructureKHR
VULKAN_HPP_NODISCARD vk::Result copyAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::setLatencyMarkerNV
void setLatencyMarkerNV(vk::SwapchainKHR swapchain, const vk::SetLatencyMarkerInfoNV &latencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements2
void getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageViewOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getImageViewOpaqueCaptureDescriptorDataEXT(const vk::ImageViewCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyOpticalFlowSessionNV
void destroyOpticalFlowSessionNV(vk::OpticalFlowSessionNV session, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPrivateDataSlot
void destroyPrivateDataSlot(vk::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PipelineLayout pipelineLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setHdrMetadataEXT
void setHdrMetadataEXT(uint32_t swapchainCount, const vk::SwapchainKHR *pSwapchains, const vk::HdrMetadataEXT *pMetadata, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::displayPowerControlEXT
VULKAN_HPP_NODISCARD Result displayPowerControlEXT(vk::DisplayKHR display, const vk::DisplayPowerInfoEXT *pDisplayPowerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SwapchainKHR >::type createSharedSwapchainKHR(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroySampler
void destroySampler(vk::Sampler sampler, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPerformanceParameterINTEL
VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRenderPass2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass2KHR(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createValidationCacheEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::ValidationCacheEXT >::type createValidationCacheEXT(const vk::ValidationCacheCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSwapchainKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SwapchainKHR >::type createSwapchainKHR(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureHandleNV
VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirementsKHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getGeneratedCommandsMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createAccelerationStructureNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::AccelerationStructureNV, Dispatch > >::type createAccelerationStructureNVUnique(const vk::AccelerationStructureCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPastPresentationTimingGOOGLE
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator > >::type getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, PastPresentationTimingGOOGLEAllocator &pastPresentationTimingGOOGLEAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::importSemaphoreFdKHR
VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR(const vk::ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::resetQueryPool
void resetQueryPool(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getQueryPoolResult
VULKAN_HPP_NODISCARD ResultValue< DataType > getQueryPoolResult(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::setDebugUtilsObjectTagEXT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(const vk::DebugUtilsObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::VideoSessionKHR videoSession, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PipelineCache pipelineCache, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::Device
VULKAN_HPP_CONSTEXPR Device(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8794

vk::Device::createCommandPoolUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CommandPool, Dispatch > >::type createCommandPoolUnique(const vk::CommandPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindImageMemory
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory(vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyPrivateDataSlot
void destroyPrivateDataSlot(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFenceFdKHR
VULKAN_HPP_NODISCARD Result getFenceFdKHR(const vk::FenceGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getVideoSessionMemoryRequirementsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator > >::type getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::release
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type release(vk::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::Event event, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRenderAreaGranularity
VULKAN_HPP_NODISCARD vk::Extent2D getRenderAreaGranularity(vk::RenderPass renderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateCommandBuffers
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CommandBuffer, CommandBufferAllocator > >::type allocateCommandBuffers(const vk::CommandBufferAllocateInfo &allocateInfo, CommandBufferAllocator &commandBufferAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroySamplerYcbcrConversion
void destroySamplerYcbcrConversion(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageDrmFormatModifierPropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageDrmFormatModifierPropertiesEXT >::type getImageDrmFormatModifierPropertiesEXT(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPipelineLayoutUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PipelineLayout, Dispatch > >::type createPipelineLayoutUnique(const vk::PipelineLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::writeMicromapsPropertiesEXT
VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT(uint32_t micromapCount, const vk::MicromapEXT *pMicromaps, vk::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDeferredOperationKHR
VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(const vk::AllocationCallbacks *pAllocator, vk::DeferredOperationKHR *pDeferredOperation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::signalSemaphore
VULKAN_HPP_NODISCARD Result signalSemaphore(const vk::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getBufferOpaqueCaptureDescriptorDataEXT(const vk::BufferCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::mapMemory2KHR
VULKAN_HPP_NODISCARD Result mapMemory2KHR(const vk::MemoryMapInfoKHR *pMemoryMapInfo, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindBufferMemory2KHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory2KHR(vk::ArrayProxy< const vk::BindBufferMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyShaderModule
void destroyShaderModule(vk::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::QueryPool queryPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyImageView
void destroyImageView(vk::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createVideoSessionKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::VideoSessionKHR, Dispatch > >::type createVideoSessionKHRUnique(const vk::VideoSessionCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRayTracingPipelinesKHR
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements2
void getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::VideoSessionParametersKHR videoSessionParameters, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelinesNVUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::CuModuleNVX module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirements2
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getVideoSessionMemoryRequirementsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator > >::type getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, VideoSessionMemoryRequirementsKHRAllocator &videoSessionMemoryRequirementsKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(const vk::AccelerationStructureCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::AccelerationStructureKHR *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createFence
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type createFence(const vk::FenceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureBuildSizesKHR
void getAccelerationStructureBuildSizesKHR(vk::AccelerationStructureBuildTypeKHR buildType, const vk::AccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, vk::AccelerationStructureBuildSizesInfoKHR *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquirePerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(const vk::PerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, vk::PerformanceConfigurationINTEL *pConfiguration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDeferredOperationResultKHR
VULKAN_HPP_NODISCARD vk::Result getDeferredOperationResultKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPipelineLayout
void destroyPipelineLayout(vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutSupportKHR
void getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, vk::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const vk::AccelerationStructureCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getShaderBinaryDataEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderBinaryDataEXT(vk::ShaderEXT shader, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getGroupPeerMemoryFeatures
VULKAN_HPP_NODISCARD vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSemaphoreFdKHR
VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR(const vk::SemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::releaseProfilingLockKHR
void releaseProfilingLockKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindImageMemory2
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory2(vk::ArrayProxy< const vk::BindImageMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyBufferView
void destroyBufferView(vk::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::operator==
bool operator==(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8813

vk::Device::destroy
void destroy(vk::DescriptorPool descriptorPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Framebuffer framebuffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineIndirectMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayoutKHR
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getAccelerationStructureBuildSizesKHR
VULKAN_HPP_NODISCARD vk::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(vk::AccelerationStructureBuildTypeKHR buildType, const vk::AccelerationStructureBuildGeometryInfoKHR &buildInfo, vk::ArrayProxy< const uint32_t > const &maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS

vk::Device::createRenderPass2Unique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPass2Unique(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const vk::AccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateDescriptorSets
VULKAN_HPP_NODISCARD Result allocateDescriptorSets(const vk::DescriptorSetAllocateInfo *pAllocateInfo, vk::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::SwapchainKHR swapchain, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getShaderInfoAMD
VULKAN_HPP_NODISCARD Result getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements2KHR
void getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPipelineCache
VULKAN_HPP_NODISCARD Result createPipelineCache(const vk::PipelineCacheCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PipelineCache *pPipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelinePropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::BaseOutStructure >::type getPipelinePropertiesEXT(const vk::PipelineInfoEXT &pipelineInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::updateDescriptorSetWithTemplateKHR
void updateDescriptorSetWithTemplateKHR(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindBufferMemory2KHR
VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR(uint32_t bindInfoCount, const vk::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyCuFunctionNVX
void destroyCuFunctionNVX(vk::CuFunctionNVX function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRenderPass
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass(const vk::RenderPassCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorSetLayoutSupportKHR
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getQueryPoolResults
VULKAN_HPP_NODISCARD ResultValue< std::vector< DataType, DataTypeAllocator > > getQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryHostPointerPropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::MemoryHostPointerPropertiesEXT >::type getMemoryHostPointerPropertiesEXT(vk::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::freeMemory
void freeMemory(vk::DeviceMemory memory, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateMemory
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceMemory >::type allocateMemory(const vk::MemoryAllocateInfo &allocateInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyDeferredOperationKHR
void destroyDeferredOperationKHR(vk::DeferredOperationKHR operation, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyBuffer
void destroyBuffer(vk::Buffer buffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirementsKHR
void getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createCuFunctionNVX
VULKAN_HPP_NODISCARD ResultValueType< vk::CuFunctionNVX >::type createCuFunctionNVX(const vk::CuFunctionCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createVideoSessionKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoSessionKHR >::type createVideoSessionKHR(const vk::VideoSessionCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::signalSemaphoreKHR
VULKAN_HPP_NODISCARD Result signalSemaphoreKHR(const vk::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::deferredOperationJoinKHR
VULKAN_HPP_NODISCARD vk::Result deferredOperationJoinKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createMicromapEXT
VULKAN_HPP_NODISCARD Result createMicromapEXT(const vk::MicromapCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::MicromapEXT *pMicromap, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::RenderPass renderPass, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout2KHR
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::AccelerationStructureKHR accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateCommandBuffers
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CommandBuffer, CommandBufferAllocator > >::type allocateCommandBuffers(const vk::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSemaphore
VULKAN_HPP_NODISCARD Result createSemaphore(const vk::SemaphoreCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Semaphore *pSemaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelinesKHRUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorSetLayoutSupport
void getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, vk::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShadersEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ShaderEXT, ShaderEXTAllocator > >::type createShadersEXT(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, ShaderEXTAllocator &shaderEXTAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createVideoSessionKHR
VULKAN_HPP_NODISCARD Result createVideoSessionKHR(const vk::VideoSessionCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::VideoSessionKHR *pVideoSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Pipeline pipeline, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SwapchainKHR, Dispatch > >::type createSharedSwapchainKHRUnique(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRenderPass
VULKAN_HPP_NODISCARD Result createRenderPass(const vk::RenderPassCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::DescriptorSetLayout descriptorSetLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createVideoSessionParametersKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::VideoSessionParametersKHR, Dispatch > >::type createVideoSessionParametersKHRUnique(const vk::VideoSessionParametersCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createMicromapEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::MicromapEXT >::type createMicromapEXT(const vk::MicromapCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getAccelerationStructureCompatibilityKHR
VULKAN_HPP_NODISCARD vk::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR(const vk::AccelerationStructureVersionInfoKHR &versionInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::updateVideoSessionParametersKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type updateVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::VideoSessionParametersUpdateInfoKHR &updateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindVideoSessionMemoryKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindVideoSessionMemoryKHR(vk::VideoSessionKHR videoSession, vk::ArrayProxy< const vk::BindVideoSessionMemoryInfoKHR > const &bindSessionMemoryInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createAccelerationStructureKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::AccelerationStructureKHR, Dispatch > >::type createAccelerationStructureKHRUnique(const vk::AccelerationStructureCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSampler
VULKAN_HPP_NODISCARD Result createSampler(const vk::SamplerCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Sampler *pSampler, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryOpaqueCaptureAddress
uint64_t getMemoryOpaqueCaptureAddress(const vk::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRenderingAreaGranularityKHR
VULKAN_HPP_NODISCARD vk::Extent2D getRenderingAreaGranularityKHR(const vk::RenderingAreaInfoKHR &renderingAreaInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setLatencySleepModeNV
VULKAN_HPP_NODISCARD Result setLatencySleepModeNV(vk::SwapchainKHR swapchain, const vk::LatencySleepModeInfoNV *pSleepModeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::uninitializePerformanceApiINTEL
void uninitializePerformanceApiINTEL(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferOpaqueCaptureAddressKHR
uint64_t getBufferOpaqueCaptureAddressKHR(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShadersEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::ShaderEXT, Dispatch >, ShaderEXTAllocator > >::type createShadersEXTUnique(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRayTracingPipelinesKHR
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoKHR *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageViewAddressNVX
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageViewAddressPropertiesNVX >::type getImageViewAddressNVX(vk::ImageView imageView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getGroupPresentCapabilitiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceGroupPresentCapabilitiesKHR >::type getGroupPresentCapabilitiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements2KHR
void getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createValidationCacheEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ValidationCacheEXT, Dispatch > >::type createValidationCacheEXTUnique(const vk::ValidationCacheCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryHostPointerPropertiesEXT
VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(vk::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, vk::MemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirements2KHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPerformanceParameterINTEL
VULKAN_HPP_NODISCARD ResultValueType< vk::PerformanceValueINTEL >::type getPerformanceParameterINTEL(vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSharedSwapchainsKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::SwapchainKHR, Dispatch >, SwapchainKHRAllocator > >::type createSharedSwapchainsKHRUnique(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyIndirectCommandsLayoutNV
void destroyIndirectCommandsLayoutNV(vk::IndirectCommandsLayoutNV indirectCommandsLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorPoolUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorPool, Dispatch > >::type createDescriptorPoolUnique(const vk::DescriptorPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineExecutableInternalRepresentationsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator > >::type getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, PipelineExecutableInternalRepresentationKHRAllocator &pipelineExecutableInternalRepresentationKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createVideoSessionParametersKHR
VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(const vk::VideoSessionParametersCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::VideoSessionParametersKHR *pVideoSessionParameters, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::resetFences
VULKAN_HPP_NODISCARD Result resetFences(uint32_t fenceCount, const vk::Fence *pFences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mapMemory2KHR
VULKAN_HPP_NODISCARD ResultValueType< void * >::type mapMemory2KHR(const vk::MemoryMapInfoKHR &memoryMapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::updateVideoSessionParametersKHR
VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::VideoSessionParametersUpdateInfoKHR *pUpdateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRenderPass2
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass2(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirementsKHR
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createImage
VULKAN_HPP_NODISCARD Result createImage(const vk::ImageCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Image *pImage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPipeline
void destroyPipeline(vk::Pipeline pipeline, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::compileDeferredNV
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type compileDeferredNV(vk::Pipeline pipeline, uint32_t shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyShaderEXT
void destroyShaderEXT(vk::ShaderEXT shader, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDeferredOperationKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DeferredOperationKHR, Dispatch > >::type createDeferredOperationKHRUnique(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindBufferMemory2
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory2(vk::ArrayProxy< const vk::BindBufferMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferMemoryRequirements
void getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShaderEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::ShaderEXT >::type createShaderEXT(const vk::ShaderCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyMemoryToAccelerationStructureKHR
VULKAN_HPP_NODISCARD vk::Result copyMemoryToAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createComputePipeline
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createComputePipeline(vk::PipelineCache pipelineCache, const vk::ComputePipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSubresourceLayout
void getImageSubresourceLayout(vk::Image image, const vk::ImageSubresource *pSubresource, vk::SubresourceLayout *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirementsKHR
void getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createBuffer
VULKAN_HPP_NODISCARD Result createBuffer(const vk::BufferCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Buffer *pBuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorSetLayout
void destroyDescriptorSetLayout(vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutBindingOffsetEXT
VULKAN_HPP_NODISCARD vk::DeviceSize getDescriptorSetLayoutBindingOffsetEXT(vk::DescriptorSetLayout layout, uint32_t binding, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setPrivateDataEXT
ResultValueType< void >::type setPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirements
void getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PrivateDataSlot privateDataSlot, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGeneratedCommandsMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createComputePipelines
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createComputePipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRayTracingCaptureReplayShaderGroupHandleKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingCaptureReplayShaderGroupHandleKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferOpaqueCaptureAddress
uint64_t getBufferOpaqueCaptureAddress(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDynamicRenderingTilePropertiesQCOM
Result getDynamicRenderingTilePropertiesQCOM(const vk::RenderingInfo *pRenderingInfo, vk::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::ImageView imageView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::MicromapEXT micromap, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createCommandPool
VULKAN_HPP_NODISCARD ResultValueType< vk::CommandPool >::type createCommandPool(const vk::CommandPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::writeMicromapsPropertyEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeMicromapsPropertyEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSamplerYcbcrConversionKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SamplerYcbcrConversion >::type createSamplerYcbcrConversionKHR(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSwapchainCounterEXT
VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT(vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::setPrivateData
ResultValueType< void >::type setPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI
VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(vk::RenderPass renderpass, vk::Extent2D *pMaxWorkgroupSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::freeCommandBuffers
void freeCommandBuffers(vk::CommandPool commandPool, vk::ArrayProxy< const vk::CommandBuffer > const &commandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::ShaderModule shaderModule, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyQueryPool
void destroyQueryPool(vk::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFramebufferTilePropertiesQCOM
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TilePropertiesQCOM, TilePropertiesQCOMAllocator > >::type getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createEvent
VULKAN_HPP_NODISCARD Result createEvent(const vk::EventCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Event *pEvent, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createGraphicsPipelinesUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createGraphicsPipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorEXT
void getDescriptorEXT(const vk::DescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFramebufferTilePropertiesQCOM
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TilePropertiesQCOM, TilePropertiesQCOMAllocator > >::type getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, TilePropertiesQCOMAllocator &tilePropertiesQCOMAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator > getImageSparseMemoryRequirements(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getCalibratedTimestampsEXT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsEXT(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::resetFences
ResultValueType< void >::type resetFences(vk::ArrayProxy< const vk::Fence > const &fences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createIndirectCommandsLayoutNVUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::IndirectCommandsLayoutNV, Dispatch > >::type createIndirectCommandsLayoutNVUnique(const vk::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createCuModuleNVX
VULKAN_HPP_NODISCARD ResultValueType< vk::CuModuleNVX >::type createCuModuleNVX(const vk::CuModuleCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRayTracingPipelinesKHRUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::Framebuffer framebuffer, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyPipeline
void destroyPipeline(vk::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyRenderPass
void destroyRenderPass(vk::RenderPass renderPass, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSamplerYcbcrConversion
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(const vk::SamplerYcbcrConversionCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySemaphore
void destroySemaphore(vk::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::AccelerationStructureKHR accelerationStructure, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorSetLayout
VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorSetLayout *pSetLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageDrmFormatModifierPropertiesEXT
VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRayTracingShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createCommandPool
VULKAN_HPP_NODISCARD Result createCommandPool(const vk::CommandPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CommandPool *pCommandPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShadersEXT
VULKAN_HPP_NODISCARD Result createShadersEXT(uint32_t createInfoCount, const vk::ShaderCreateInfoEXT *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::ShaderEXT *pShaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySamplerYcbcrConversion
void destroySamplerYcbcrConversion(vk::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineExecutableStatisticsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator > >::type getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::operator!=
bool operator!=(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8818

vk::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryFdKHR
VULKAN_HPP_NODISCARD ResultValueType< int >::type getMemoryFdKHR(const vk::MemoryGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::flushMappedMemoryRanges
VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges(uint32_t memoryRangeCount, const vk::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::latencySleepNV
ResultValueType< void >::type latencySleepNV(vk::SwapchainKHR swapchain, const vk::LatencySleepInfoNV &sleepInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::Sampler sampler, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSwapchainStatusKHR
VULKAN_HPP_NODISCARD vk::Result getSwapchainStatusKHR(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPipelineCacheUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PipelineCache, Dispatch > >::type createPipelineCacheUnique(const vk::PipelineCacheCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::CuFunctionNVX function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateCommandBuffersUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::CommandBuffer, Dispatch >, CommandBufferAllocator > >::type allocateCommandBuffersUnique(const vk::CommandBufferAllocateInfo &allocateInfo, CommandBufferAllocator &commandBufferAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::unmapMemory2KHR
Result unmapMemory2KHR(const vk::MemoryUnmapInfoKHR *pMemoryUnmapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShadersEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ShaderEXT, ShaderEXTAllocator > >::type createShadersEXT(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getEventStatus
VULKAN_HPP_NODISCARD vk::Result getEventStatus(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::waitSemaphoresKHR
VULKAN_HPP_NODISCARD Result waitSemaphoresKHR(const vk::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getCalibratedTimestampsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsKHR(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::DeferredOperationKHR operation, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyImageToMemoryEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyImageToMemoryEXT(const vk::CopyImageToMemoryInfoEXT &copyImageToMemoryInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyImageToMemoryEXT
VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT(const vk::CopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getEncodedVideoSessionParametersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::StructureChain< X, Y, Z... >, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPrivateData
void getPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::freeDescriptorSets
Result freeDescriptorSets(vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorUpdateTemplate
void destroyDescriptorUpdateTemplate(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout
VULKAN_HPP_NODISCARD vk::SubresourceLayout getImageSubresourceLayout(vk::Image image, const vk::ImageSubresource &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGeneratedCommandsMemoryRequirementsNV
void getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::waitForFences
VULKAN_HPP_NODISCARD vk::Result waitForFences(vk::ArrayProxy< const vk::Fence > const &fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::acquirePerformanceConfigurationINTELUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PerformanceConfigurationINTEL, Dispatch > >::type acquirePerformanceConfigurationINTELUnique(const vk::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindVideoSessionMemoryKHR
VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(vk::VideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const vk::BindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::CommandPool commandPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirementsKHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::Fence fence, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::CType
VkDevice CType
Definition: vulkan_handles.hpp:8784

vk::Device::getShaderModuleIdentifierEXT
VULKAN_HPP_NODISCARD vk::ShaderModuleIdentifierEXT getShaderModuleIdentifierEXT(vk::ShaderModule shaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT(const vk::ImageCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyFence
void destroyFence(vk::Fence fence, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout2EXT
void getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR *pSubresource, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createComputePipelines
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createComputePipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorUpdateTemplateKHR
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(const vk::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::waitIdle
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelinePropertiesEXT
VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT(const vk::PipelineInfoEXT *pPipelineInfo, vk::BaseOutStructure *pPipelineProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyMicromapEXT
void destroyMicromapEXT(vk::MicromapEXT micromap, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirementsKHR
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mergeValidationCachesEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type mergeValidationCachesEXT(vk::ValidationCacheEXT dstCache, vk::ArrayProxy< const vk::ValidationCacheEXT > const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::IndirectCommandsLayoutNV indirectCommandsLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySwapchainKHR
void destroySwapchainKHR(vk::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::CommandPool commandPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineExecutablePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator > >::type getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR &pipelineInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMicromapCompatibilityEXT
VULKAN_HPP_NODISCARD vk::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT(const vk::MicromapVersionInfoEXT &versionInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineExecutablePropertiesKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, vk::PipelineExecutablePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyImage
void destroyImage(vk::Image image, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineExecutableInternalRepresentationsKHR
VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR *pInternalRepresentations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferOpaqueCaptureAddress
uint64_t getBufferOpaqueCaptureAddress(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRayTracingShaderGroupStackSizeKHR
DeviceSize getRayTracingShaderGroupStackSizeKHR(vk::Pipeline pipeline, uint32_t group, vk::ShaderGroupShaderKHR groupShader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createIndirectCommandsLayoutNV
VULKAN_HPP_NODISCARD ResultValueType< vk::IndirectCommandsLayoutNV >::type createIndirectCommandsLayoutNV(const vk::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySampler
void destroySampler(vk::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDynamicRenderingTilePropertiesQCOM
VULKAN_HPP_NODISCARD vk::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFenceStatus
VULKAN_HPP_NODISCARD vk::Result getFenceStatus(vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferAddress
vk::DeviceAddress getBufferAddress(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getQueue
void getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineIndirectMemoryRequirementsNV
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryRemoteAddressNV
VULKAN_HPP_NODISCARD ResultValueType< vk::RemoteAddressNV >::type getMemoryRemoteAddressNV(const vk::MemoryGetRemoteAddressInfoNV &memoryGetRemoteAddressInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::allocateCommandBuffers
VULKAN_HPP_NODISCARD Result allocateCommandBuffers(const vk::CommandBufferAllocateInfo *pAllocateInfo, vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createShaderModule
VULKAN_HPP_NODISCARD ResultValueType< vk::ShaderModule >::type createShaderModule(const vk::ShaderModuleCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyAccelerationStructureToMemoryKHR
VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements
void getBufferMemoryRequirements(vk::Buffer buffer, vk::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRenderPass2KHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPass2KHRUnique(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageViewHandleNVX
uint32_t getImageViewHandleNVX(const vk::ImageViewHandleInfoNVX &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::Device
VULKAN_HPP_CONSTEXPR Device()=default

vk::Device::getImageMemoryRequirements2KHR
void getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::DeferredOperationKHR operation, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayout2EXT
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPipelineCacheData
VULKAN_HPP_NODISCARD Result getPipelineCacheData(vk::PipelineCache pipelineCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateDescriptorSets
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DescriptorSet, DescriptorSetAllocator > >::type allocateDescriptorSets(const vk::DescriptorSetAllocateInfo &allocateInfo, DescriptorSetAllocator &descriptorSetAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::waitSemaphoresKHR
VULKAN_HPP_NODISCARD vk::Result waitSemaphoresKHR(const vk::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineExecutablePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator > >::type getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR &pipelineInfo, PipelineExecutablePropertiesKHRAllocator &pipelineExecutablePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getProcAddr
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Fence fence, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPastPresentationTimingGOOGLE
VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, uint32_t *pPresentationTimingCount, vk::PastPresentationTimingGOOGLE *pPresentationTimings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::releaseSwapchainImagesEXT
ResultValueType< void >::type releaseSwapchainImagesEXT(const vk::ReleaseSwapchainImagesInfoEXT &releaseInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getImageOpaqueCaptureDescriptorDataEXT(const vk::ImageCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSemaphoreCounterValueKHR
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSemaphoreCounterValueKHR(vk::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::OpticalFlowSessionNV session, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFramebufferTilePropertiesQCOM
VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, uint32_t *pPropertiesCount, vk::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutSupportKHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createBuffer
VULKAN_HPP_NODISCARD ResultValueType< vk::Buffer >::type createBuffer(const vk::BufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::BufferView bufferView, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorUpdateTemplate
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(const vk::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::VideoSessionParametersKHR videoSessionParameters, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSwapchainKHR
VULKAN_HPP_NODISCARD Result createSwapchainKHR(const vk::SwapchainCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SwapchainKHR *pSwapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createGraphicsPipelines
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createGraphicsPipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSwapchainImagesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Image, ImageAllocator > >::type getSwapchainImagesKHR(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::SamplerYcbcrConversion ycbcrConversion, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFenceFdKHR
VULKAN_HPP_NODISCARD ResultValueType< int >::type getFenceFdKHR(const vk::FenceGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyDescriptorUpdateTemplateKHR
void destroyDescriptorUpdateTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutBindingOffsetEXT
void getDescriptorSetLayoutBindingOffsetEXT(vk::DescriptorSetLayout layout, uint32_t binding, vk::DeviceSize *pOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquirePerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD ResultValueType< vk::PerformanceConfigurationINTEL >::type acquirePerformanceConfigurationINTEL(const vk::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createFramebuffer
VULKAN_HPP_NODISCARD Result createFramebuffer(const vk::FramebufferCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Framebuffer *pFramebuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRenderPass2
VULKAN_HPP_NODISCARD Result createRenderPass2(const vk::RenderPassCreateInfo2 *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferAddress
DeviceAddress getBufferAddress(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorSetLayoutUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorSetLayout, Dispatch > >::type createDescriptorSetLayoutUnique(const vk::DescriptorSetLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineIndirectAddressNV
vk::DeviceAddress getPipelineIndirectAddressNV(const vk::PipelineIndirectDeviceAddressInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyAccelerationStructureKHR
void destroyAccelerationStructureKHR(vk::AccelerationStructureKHR accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelinesKHR
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyBufferView
void destroyBufferView(vk::BufferView bufferView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorPool
void destroyDescriptorPool(vk::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::resetEvent
ResultValueType< void >::type resetEvent(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSwapchainImagesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Image, ImageAllocator > >::type getSwapchainImagesKHR(vk::SwapchainKHR swapchain, ImageAllocator &imageAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyMemoryToImageEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyMemoryToImageEXT(const vk::CopyMemoryToImageInfoEXT &copyMemoryToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::resetDescriptorPool
void resetDescriptorPool(vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorUpdateTemplate
void destroyDescriptorUpdateTemplate(vk::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindImageMemory2KHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory2KHR(vk::ArrayProxy< const vk::BindImageMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getEncodedVideoSessionParametersKHR
VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, vk::VideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::waitSemaphores
VULKAN_HPP_NODISCARD Result waitSemaphores(const vk::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyFence
void destroyFence(vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSubresourceLayoutKHR
void getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR *pInfo, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getLatencyTimingsNV
void getLatencyTimingsNV(vk::SwapchainKHR swapchain, vk::GetLatencyMarkerInfoNV *pLatencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::allocateCommandBuffersUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::CommandBuffer, Dispatch >, CommandBufferAllocator > >::type allocateCommandBuffersUnique(const vk::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createImage
VULKAN_HPP_NODISCARD ResultValueType< vk::Image >::type createImage(const vk::ImageCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createSamplerYcbcrConversionUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionUnique(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getDescriptorEXT
void getDescriptorEXT(const vk::DescriptorGetInfoEXT &descriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getValidationCacheDataEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroy
void destroy(vk::ShaderEXT shader, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createPrivateDataSlotEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::PrivateDataSlot >::type createPrivateDataSlotEXT(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createPrivateDataSlotEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotEXTUnique(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSubresourceLayoutKHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelineNV
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createRayTracingPipelineNV(vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements2
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryOpaqueCaptureAddress
uint64_t getMemoryOpaqueCaptureAddress(const vk::DeviceMemoryOpaqueCaptureAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquireProfilingLockKHR
VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR(const vk::AcquireProfilingLockInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::registerDisplayEventEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type registerDisplayEventEXTUnique(vk::DisplayKHR display, const vk::DisplayEventInfoEXT &displayEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::mergePipelineCaches
VULKAN_HPP_NODISCARD Result mergePipelineCaches(vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getGroupPeerMemoryFeatures
void getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyRenderPass
void destroyRenderPass(vk::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createQueryPool
VULKAN_HPP_NODISCARD Result createQueryPool(const vk::QueryPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::QueryPool *pQueryPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createBufferUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Buffer, Dispatch > >::type createBufferUnique(const vk::BufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::debugMarkerSetObjectTagEXT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(const vk::DebugMarkerObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Semaphore semaphore, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PipelineCache pipelineCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyDescriptorSetLayout
void destroyDescriptorSetLayout(vk::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements
VULKAN_HPP_NODISCARD vk::MemoryRequirements getBufferMemoryRequirements(vk::Buffer buffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::acquireNextImageKHR
VULKAN_HPP_NODISCARD Result acquireNextImageKHR(vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageViewHandleNVX
uint32_t getImageViewHandleNVX(const vk::ImageViewHandleInfoNVX *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryOpaqueCaptureAddressKHR
uint64_t getMemoryOpaqueCaptureAddressKHR(const vk::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::mergeValidationCachesEXT
VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT(vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getSwapchainCounterEXT
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSwapchainCounterEXT(vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryRemoteAddressNV
VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV(const vk::MemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, vk::RemoteAddressNV *pAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createImageViewUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ImageView, Dispatch > >::type createImageViewUnique(const vk::ImageViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createQueryPool
VULKAN_HPP_NODISCARD ResultValueType< vk::QueryPool >::type createQueryPool(const vk::QueryPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::transitionImageLayoutEXT
VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT(uint32_t transitionCount, const vk::HostImageLayoutTransitionInfoEXT *pTransitions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createGraphicsPipelines
VULKAN_HPP_NODISCARD Result createGraphicsPipelines(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getEncodedVideoSessionParametersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::StructureChain< X, Y, Z... >, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getBufferAddressEXT
vk::DeviceAddress getBufferAddressEXT(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageSparseMemoryRequirements
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator > getImageSparseMemoryRequirements(vk::Image image, SparseImageMemoryRequirementsAllocator &sparseImageMemoryRequirementsAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createRayTracingPipelinesNVUnique
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::updateDescriptorSetWithTemplate
void updateDescriptorSetWithTemplate(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelinesNV
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSwapchainImagesKHR
VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR(vk::SwapchainKHR swapchain, uint32_t *pSwapchainImageCount, vk::Image *pSwapchainImages, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements
VULKAN_HPP_NODISCARD vk::MemoryRequirements getImageMemoryRequirements(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::OpticalFlowSessionNV session, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferMemoryRequirements2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSwapchainKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SwapchainKHR, Dispatch > >::type createSwapchainKHRUnique(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRayTracingShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getQueue2
VULKAN_HPP_NODISCARD vk::Queue getQueue2(const vk::DeviceQueueInfo2 &queueInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getFaultInfoEXT
VULKAN_HPP_NODISCARD Result getFaultInfoEXT(vk::DeviceFaultCountsEXT *pFaultCounts, vk::DeviceFaultInfoEXT *pFaultInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyVideoSessionKHR
void destroyVideoSessionKHR(vk::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroySwapchainKHR
void destroySwapchainKHR(vk::SwapchainKHR swapchain, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Image image, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createImageView
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageView >::type createImageView(const vk::ImageViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::setDebugUtilsObjectNameEXT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setDebugUtilsObjectNameEXT(const vk::DebugUtilsObjectNameInfoEXT &nameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageMemoryRequirements2
void getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createQueryPoolUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::QueryPool, Dispatch > >::type createQueryPoolUnique(const vk::QueryPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createDescriptorPool
VULKAN_HPP_NODISCARD Result createDescriptorPool(const vk::DescriptorPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorPool *pDescriptorPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createAccelerationStructureKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::AccelerationStructureKHR >::type createAccelerationStructureKHR(const vk::AccelerationStructureCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getSamplerOpaqueCaptureDescriptorDataEXT
VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(const vk::SamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetHostMappingVALVE
void getDescriptorSetHostMappingVALVE(vk::DescriptorSet descriptorSet, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroyFramebuffer
void destroyFramebuffer(vk::Framebuffer framebuffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::buildMicromapsEXT
VULKAN_HPP_NODISCARD vk::Result buildMicromapsEXT(vk::DeferredOperationKHR deferredOperation, vk::ArrayProxy< const vk::MicromapBuildInfoEXT > const &infos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::createOpticalFlowSessionNV
VULKAN_HPP_NODISCARD ResultValueType< vk::OpticalFlowSessionNV >::type createOpticalFlowSessionNV(const vk::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getMemoryOpaqueCaptureAddressKHR
uint64_t getMemoryOpaqueCaptureAddressKHR(const vk::DeviceMemoryOpaqueCaptureAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::freeDescriptorSets
void freeDescriptorSets(vk::DescriptorPool descriptorPool, vk::ArrayProxy< const vk::DescriptorSet > const &descriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::VideoSessionKHR videoSession, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSemaphore
VULKAN_HPP_NODISCARD ResultValueType< vk::Semaphore >::type createSemaphore(const vk::SemaphoreCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyQueryPool
void destroyQueryPool(vk::QueryPool queryPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createComputePipelineUnique
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createComputePipelineUnique(vk::PipelineCache pipelineCache, const vk::ComputePipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getValidationCacheDataEXT
VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getVideoSessionMemoryRequirementsKHR
VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, vk::VideoSessionMemoryRequirementsKHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getImageMemoryRequirements
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRayTracingShaderGroupHandleKHR
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::signalSemaphoreKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type signalSemaphoreKHR(const vk::SemaphoreSignalInfo &signalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getImageSparseMemoryRequirements
void getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getRenderingAreaGranularityKHR
void getRenderingAreaGranularityKHR(const vk::RenderingAreaInfoKHR *pRenderingAreaInfo, vk::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::importFenceFdKHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type importFenceFdKHR(const vk::ImportFenceFdInfoKHR &importFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyBuffer
void destroyBuffer(vk::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getDescriptorSetLayoutSizeEXT
VULKAN_HPP_NODISCARD vk::DeviceSize getDescriptorSetLayoutSizeEXT(vk::DescriptorSetLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::QueryPool queryPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createOpticalFlowSessionNV
VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV(const vk::OpticalFlowSessionCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::OpticalFlowSessionNV *pSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createRayTracingPipelinesNV
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::bindImageMemory2KHR
VULKAN_HPP_NODISCARD Result bindImageMemory2KHR(uint32_t bindInfoCount, const vk::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::releasePerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type releasePerformanceConfigurationINTEL(vk::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getPipelineCacheData
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getPipelineCacheData(vk::PipelineCache pipelineCache, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingCaptureReplayShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::registerEventEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type registerEventEXT(const vk::DeviceEventInfoEXT &deviceEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::getShaderBinaryDataEXT
VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT(vk::ShaderEXT shader, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::operator=
Device & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8804

vk::Device::allocateDescriptorSetsUnique
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::DescriptorSet, Dispatch >, DescriptorSetAllocator > >::type allocateDescriptorSetsUnique(const vk::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::destroyIndirectCommandsLayoutNV
void destroyIndirectCommandsLayoutNV(vk::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getBufferAddressKHR
vk::DeviceAddress getBufferAddressKHR(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createDescriptorUpdateTemplateUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateUnique(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Device::copyMemoryToAccelerationStructureKHR
VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::createSharedSwapchainsKHR
VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::SwapchainKHR *pSwapchains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::destroy
void destroy(vk::Sampler sampler, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getPrivateDataEXT
void getPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::getMemoryFdPropertiesKHR
VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR(vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR *pMemoryFdProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::copyMicromapEXT
VULKAN_HPP_NODISCARD Result copyMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Device::bindAccelerationStructureMemoryNV
VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::DisplayKHR
Definition: vulkan_handles.hpp:2616

vk::DisplayKHR::operator=
DisplayKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2640

vk::DisplayKHR::DisplayKHR
VULKAN_HPP_CONSTEXPR DisplayKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2628

vk::DisplayKHR::operator==
bool operator==(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2649

vk::DisplayKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2675

vk::DisplayKHR::operator!=
bool operator!=(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2654

vk::DisplayKHR::operator<
bool operator<(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2659

vk::DisplayKHR::DisplayKHR
VULKAN_HPP_CONSTEXPR DisplayKHR()=default

vk::DisplayKHR::NativeType
VkDisplayKHR NativeType
Definition: vulkan_handles.hpp:2619

vk::DisplayKHR::CType
VkDisplayKHR CType
Definition: vulkan_handles.hpp:2618

vk::DisplayKHR::DisplayKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2630

vk::DisplayModeKHR
Definition: vulkan_handles.hpp:13920

vk::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_CONSTEXPR DisplayModeKHR()=default

vk::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13934

vk::DisplayModeKHR::operator=
DisplayModeKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13944

vk::DisplayModeKHR::CType
VkDisplayModeKHR CType
Definition: vulkan_handles.hpp:13922

vk::DisplayModeKHR::NativeType
VkDisplayModeKHR NativeType
Definition: vulkan_handles.hpp:13923

vk::DisplayModeKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13979

vk::DisplayModeKHR::operator==
bool operator==(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13953

vk::DisplayModeKHR::operator<
bool operator<(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13963

vk::DisplayModeKHR::operator!=
bool operator!=(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13958

vk::DisplayModeKHR::DisplayModeKHR
VULKAN_HPP_CONSTEXPR DisplayModeKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13932

vk::Event
Definition: vulkan_handles.hpp:4004

vk::Event::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4063

vk::Event::CType
VkEvent CType
Definition: vulkan_handles.hpp:4006

vk::Event::Event
VULKAN_HPP_CONSTEXPR Event()=default

vk::Event::Event
VULKAN_HPP_CONSTEXPR Event(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4016

vk::Event::operator!=
bool operator!=(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4042

vk::Event::Event
VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4018

vk::Event::operator=
Event & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4028

vk::Event::NativeType
VkEvent NativeType
Definition: vulkan_handles.hpp:4007

vk::Event::operator==
bool operator==(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4037

vk::Event::operator<
bool operator<(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4047

vk::Fence
Definition: vulkan_handles.hpp:2877

vk::Fence::NativeType
VkFence NativeType
Definition: vulkan_handles.hpp:2880

vk::Fence::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2936

vk::Fence::operator<
bool operator<(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2920

vk::Fence::Fence
VULKAN_HPP_CONSTEXPR Fence(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2889

vk::Fence::operator==
bool operator==(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2910

vk::Fence::Fence
VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2891

vk::Fence::Fence
VULKAN_HPP_CONSTEXPR Fence()=default

vk::Fence::operator=
Fence & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2901

vk::Fence::CType
VkFence CType
Definition: vulkan_handles.hpp:2879

vk::Fence::operator!=
bool operator!=(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2915

vk::Framebuffer
Definition: vulkan_handles.hpp:7757

vk::Framebuffer::operator==
bool operator==(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7790

vk::Framebuffer::operator!=
bool operator!=(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7795

vk::Framebuffer::CType
VkFramebuffer CType
Definition: vulkan_handles.hpp:7759

vk::Framebuffer::NativeType
VkFramebuffer NativeType
Definition: vulkan_handles.hpp:7760

vk::Framebuffer::operator=
Framebuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7781

vk::Framebuffer::Framebuffer
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7771

vk::Framebuffer::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7816

vk::Framebuffer::operator<
bool operator<(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7800

vk::Framebuffer::Framebuffer
VULKAN_HPP_CONSTEXPR Framebuffer()=default

vk::Framebuffer::Framebuffer
VULKAN_HPP_CONSTEXPR Framebuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7769

vk::ImageView
Definition: vulkan_handles.hpp:3396

vk::ImageView::operator==
bool operator==(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3429

vk::ImageView::ImageView
VULKAN_HPP_CONSTEXPR ImageView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3408

vk::ImageView::ImageView
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3410

vk::ImageView::CType
VkImageView CType
Definition: vulkan_handles.hpp:3398

vk::ImageView::ImageView
VULKAN_HPP_CONSTEXPR ImageView()=default

vk::ImageView::operator=
ImageView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3420

vk::ImageView::operator<
bool operator<(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3439

vk::ImageView::operator!=
bool operator!=(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3434

vk::ImageView::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3455

vk::ImageView::NativeType
VkImageView NativeType
Definition: vulkan_handles.hpp:3399

vk::Image
Definition: vulkan_handles.hpp:3651

vk::Image::operator!=
bool operator!=(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3689

vk::Image::operator<
bool operator<(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3694

vk::Image::NativeType
VkImage NativeType
Definition: vulkan_handles.hpp:3654

vk::Image::Image
VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3665

vk::Image::operator==
bool operator==(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3684

vk::Image::CType
VkImage CType
Definition: vulkan_handles.hpp:3653

vk::Image::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3710

vk::Image::Image
VULKAN_HPP_CONSTEXPR Image(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3663

vk::Image::Image
VULKAN_HPP_CONSTEXPR Image()=default

vk::Image::operator=
Image & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3675

vk::IndirectCommandsLayoutNV
Definition: vulkan_handles.hpp:7844

vk::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7858

vk::IndirectCommandsLayoutNV::operator<
bool operator<(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7890

vk::IndirectCommandsLayoutNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7906

vk::IndirectCommandsLayoutNV::CType
VkIndirectCommandsLayoutNV CType
Definition: vulkan_handles.hpp:7846

vk::IndirectCommandsLayoutNV::operator!=
bool operator!=(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7885

vk::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7856

vk::IndirectCommandsLayoutNV::operator==
bool operator==(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7880

vk::IndirectCommandsLayoutNV::NativeType
VkIndirectCommandsLayoutNV NativeType
Definition: vulkan_handles.hpp:7847

vk::IndirectCommandsLayoutNV::IndirectCommandsLayoutNV
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV()=default

vk::IndirectCommandsLayoutNV::operator=
IndirectCommandsLayoutNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7871

vk::Instance
Definition: vulkan_handles.hpp:15429

vk::Instance::Instance
Instance(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15443

vk::Instance::operator<
bool operator<(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15470

vk::Instance::destroy
void destroy(vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::operator=
Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15445

vk::Instance::createDebugUtilsMessengerEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::DebugUtilsMessengerEXT >::type createDebugUtilsMessengerEXT(const vk::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::enumeratePhysicalDevices
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDevice, PhysicalDeviceAllocator > >::type enumeratePhysicalDevices(PhysicalDeviceAllocator &physicalDeviceAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::createHeadlessSurfaceEXT
VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT(const vk::HeadlessSurfaceCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::enumeratePhysicalDeviceGroupsKHR
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(uint32_t *pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::createDebugUtilsMessengerEXT
VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(const vk::DebugUtilsMessengerCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DebugUtilsMessengerEXT *pMessenger, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::Instance
VULKAN_HPP_CONSTEXPR Instance(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15441

vk::Instance::debugReportMessageEXT
void debugReportMessageEXT(vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::submitDebugUtilsMessageEXT
void submitDebugUtilsMessageEXT(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT &callbackData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::NativeType
VkInstance NativeType
Definition: vulkan_handles.hpp:15432

vk::Instance::debugReportMessageEXT
void debugReportMessageEXT(vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const std::string &layerPrefix, const std::string &message, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroy
void destroy(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::createDisplayPlaneSurfaceKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceKHR >::type createDisplayPlaneSurfaceKHR(const vk::DisplaySurfaceCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroy
void destroy(vk::DebugUtilsMessengerEXT messenger, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::createDebugUtilsMessengerEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DebugUtilsMessengerEXT, Dispatch > >::type createDebugUtilsMessengerEXTUnique(const vk::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::enumeratePhysicalDevices
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDevice, PhysicalDeviceAllocator > >::type enumeratePhysicalDevices(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::createDisplayPlaneSurfaceKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SurfaceKHR, Dispatch > >::type createDisplayPlaneSurfaceKHRUnique(const vk::DisplaySurfaceCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::enumeratePhysicalDeviceGroups
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(uint32_t *pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroy
void destroy(const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::enumeratePhysicalDevices
VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices(uint32_t *pPhysicalDeviceCount, vk::PhysicalDevice *pPhysicalDevices, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::CType
VkInstance CType
Definition: vulkan_handles.hpp:15431

vk::Instance::createDebugReportCallbackEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DebugReportCallbackEXT, Dispatch > >::type createDebugReportCallbackEXTUnique(const vk::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroy
void destroy(vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::Instance
VULKAN_HPP_CONSTEXPR Instance()=default

vk::Instance::createHeadlessSurfaceEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SurfaceKHR, Dispatch > >::type createHeadlessSurfaceEXTUnique(const vk::HeadlessSurfaceCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroyDebugReportCallbackEXT
void destroyDebugReportCallbackEXT(vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroy
void destroy(vk::SurfaceKHR surface, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::operator=
Instance & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15451

vk::Instance::destroyDebugUtilsMessengerEXT
void destroyDebugUtilsMessengerEXT(vk::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroy
void destroy(vk::DebugReportCallbackEXT callback, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::getProcAddr
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::getProcAddr
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::operator==
bool operator==(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15460

vk::Instance::enumeratePhysicalDeviceGroups
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroups(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroy
void destroy(vk::SurfaceKHR surface, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroyDebugReportCallbackEXT
void destroyDebugReportCallbackEXT(vk::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:16067

vk::Instance::createDebugReportCallbackEXT
VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(const vk::DebugReportCallbackCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DebugReportCallbackEXT *pCallback, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::operator!=
bool operator!=(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15465

vk::Instance::createHeadlessSurfaceEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceKHR >::type createHeadlessSurfaceEXT(const vk::HeadlessSurfaceCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroySurfaceKHR
void destroySurfaceKHR(vk::SurfaceKHR surface, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::enumeratePhysicalDeviceGroupsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroupsKHR(PhysicalDeviceGroupPropertiesAllocator &physicalDeviceGroupPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::enumeratePhysicalDeviceGroups
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroups(PhysicalDeviceGroupPropertiesAllocator &physicalDeviceGroupPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::destroySurfaceKHR
void destroySurfaceKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::createDisplayPlaneSurfaceKHR
VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(const vk::DisplaySurfaceCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::destroyDebugUtilsMessengerEXT
void destroyDebugUtilsMessengerEXT(vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Instance::createDebugReportCallbackEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::DebugReportCallbackEXT >::type createDebugReportCallbackEXT(const vk::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::enumeratePhysicalDeviceGroupsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Instance::submitDebugUtilsMessageEXT
void submitDebugUtilsMessageEXT(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::MicromapEXT
Definition: vulkan_handles.hpp:4181

vk::MicromapEXT::MicromapEXT
VULKAN_HPP_CONSTEXPR MicromapEXT()=default

vk::MicromapEXT::CType
VkMicromapEXT CType
Definition: vulkan_handles.hpp:4183

vk::MicromapEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4240

vk::MicromapEXT::operator<
bool operator<(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4224

vk::MicromapEXT::NativeType
VkMicromapEXT NativeType
Definition: vulkan_handles.hpp:4184

vk::MicromapEXT::MicromapEXT
VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4195

vk::MicromapEXT::MicromapEXT
VULKAN_HPP_CONSTEXPR MicromapEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4193

vk::MicromapEXT::operator!=
bool operator!=(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4219

vk::MicromapEXT::operator==
bool operator==(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4214

vk::MicromapEXT::operator=
MicromapEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4205

vk::ObjectDestroy< NoParent, Dispatch >
Definition: vulkan.hpp:5960

vk::ObjectDestroy
Definition: vulkan.hpp:5914

vk::ObjectFree
Definition: vulkan.hpp:5996

vk::OpticalFlowSessionNV
Definition: vulkan_handles.hpp:3828

vk::OpticalFlowSessionNV::NativeType
VkOpticalFlowSessionNV NativeType
Definition: vulkan_handles.hpp:3831

vk::OpticalFlowSessionNV::operator==
bool operator==(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3864

vk::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV()=default

vk::OpticalFlowSessionNV::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3890

vk::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3842

vk::OpticalFlowSessionNV::operator=
OpticalFlowSessionNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3855

vk::OpticalFlowSessionNV::operator<
bool operator<(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3874

vk::OpticalFlowSessionNV::operator!=
bool operator!=(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3869

vk::OpticalFlowSessionNV::CType
VkOpticalFlowSessionNV CType
Definition: vulkan_handles.hpp:3830

vk::OpticalFlowSessionNV::OpticalFlowSessionNV
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3840

vk::Optional
Definition: vulkan.hpp:567

vk::PerformanceConfigurationINTEL
Definition: vulkan_handles.hpp:2964

vk::PerformanceConfigurationINTEL::operator!=
bool operator!=(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3005

vk::PerformanceConfigurationINTEL::operator<
bool operator<(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3010

vk::PerformanceConfigurationINTEL::NativeType
VkPerformanceConfigurationINTEL NativeType
Definition: vulkan_handles.hpp:2967

vk::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2978

vk::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2976

vk::PerformanceConfigurationINTEL::PerformanceConfigurationINTEL
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()=default

vk::PerformanceConfigurationINTEL::CType
VkPerformanceConfigurationINTEL CType
Definition: vulkan_handles.hpp:2966

vk::PerformanceConfigurationINTEL::operator=
PerformanceConfigurationINTEL & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2991

vk::PerformanceConfigurationINTEL::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3026

vk::PerformanceConfigurationINTEL::operator==
bool operator==(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3000

vk::PhysicalDevice
Definition: vulkan_handles.hpp:14007

vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR
VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, uint32_t *pDisplayCount, vk::DisplayKHR *pDisplays, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties2KHR
VULKAN_HPP_NODISCARD vk::FormatProperties2 getFormatProperties2KHR(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceCapabilities2KHR
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, vk::SurfaceCapabilities2KHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getPresentRectanglesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Rect2D, Rect2DAllocator > >::type getPresentRectanglesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getProperties
void getProperties(vk::PhysicalDeviceProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayProperties2KHR, DisplayProperties2KHRAllocator > >::type getDisplayProperties2KHR(DisplayProperties2KHRAllocator &displayProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFormatProperties2KHR
void getFormatProperties2KHR(vk::Format format, vk::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::operator=
PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14023

vk::PhysicalDevice::getProperties2
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties2 getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalFencePropertiesKHR
void getExternalFencePropertiesKHR(const vk::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, vk::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFormatProperties2KHR(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalSemaphoreProperties
void getExternalSemaphoreProperties(const vk::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15401

vk::PhysicalDevice::getCalibrateableTimeDomainsKHR
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR(uint32_t *pTimeDomainCount, vk::TimeDomainKHR *pTimeDomains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlaneCapabilities2KHR
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(const vk::DisplayPlaneInfo2KHR *pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator > >::type getSupportedFramebufferMixedSamplesCombinationsNV(FramebufferMixedSamplesCombinationNVAllocator &framebufferMixedSamplesCombinationNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoEncodeQualityLevelPropertiesKHR >::type getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR &qualityLevelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator > getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, SparseImageFormatPropertiesAllocator &sparseImageFormatPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfacePresentModesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PresentModeKHR, PresentModeKHRAllocator > >::type getSurfacePresentModesKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCooperativeMatrixPropertiesNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator > >::type getCooperativeMatrixPropertiesNV(CooperativeMatrixPropertiesNVAllocator &cooperativeMatrixPropertiesNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties2
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures
void getFeatures(vk::PhysicalDeviceFeatures *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getMemoryProperties2
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlanePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator > >::type getDisplayPlanePropertiesKHR(DisplayPlanePropertiesKHRAllocator &displayPlanePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getPresentRectanglesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Rect2D, Rect2DAllocator > >::type getPresentRectanglesKHR(vk::SurfaceKHR surface, Rect2DAllocator &rect2DAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMemoryProperties2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalBufferProperties
VULKAN_HPP_NODISCARD vk::ExternalBufferProperties getExternalBufferProperties(const vk::PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2
void getQueueFamilyProperties2(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getCooperativeMatrixPropertiesNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator > >::type getCooperativeMatrixPropertiesNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator > >::type getDisplayPropertiesKHR(DisplayPropertiesKHRAllocator &displayPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDrmDisplayEXT
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayKHR >::type getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceCapabilities2EXT
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::PhysicalDevice
VULKAN_HPP_CONSTEXPR PhysicalDevice()=default

vk::PhysicalDevice::PhysicalDevice
VULKAN_HPP_CONSTEXPR PhysicalDevice(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14019

vk::PhysicalDevice::getExternalBufferProperties
void getExternalBufferProperties(const vk::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, vk::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getVideoCapabilitiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoCapabilitiesKHR >::type getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::CType
VkPhysicalDevice CType
Definition: vulkan_handles.hpp:14009

vk::PhysicalDevice::getSparseImageFormatProperties
void getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t *pPropertyCount, vk::SparseImageFormatProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceFormatsKHR
VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR(vk::SurfaceKHR surface, uint32_t *pSurfaceFormatCount, vk::SurfaceFormatKHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlanePropertiesKHR
VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(uint32_t *pPropertyCount, vk::DisplayPlanePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties
void getFormatProperties(vk::Format format, vk::FormatProperties *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlaneProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator > >::type getDisplayPlaneProperties2KHR(DisplayPlaneProperties2KHRAllocator &displayPlaneProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getQueueFamilyProperties
void getQueueFamilyProperties(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getToolPropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolPropertiesEXT(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getQueueFamilyProperties2KHR
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::createDeviceUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Device, Dispatch > >::type createDeviceUnique(const vk::DeviceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::PhysicalDevice
PhysicalDevice(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14021

vk::PhysicalDevice::getProperties2
void getProperties2(vk::PhysicalDeviceProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getOpticalFlowImageFormatsNV
VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, vk::OpticalFlowImageFormatPropertiesNV *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR &qualityLevelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::NativeType
VkPhysicalDevice NativeType
Definition: vulkan_handles.hpp:14010

vk::PhysicalDevice::getFeatures2KHR
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getImageFormatProperties2KHR
VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, vk::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getCalibrateableTimeDomainsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsKHR(TimeDomainKHRAllocator &timeDomainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateDeviceExtensionProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlaneCapabilities2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayPlaneCapabilities2KHR >::type getDisplayPlaneCapabilities2KHR(const vk::DisplayPlaneInfo2KHR &displayPlaneInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getQueueFamilyProperties2KHR
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2KHR(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlanePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator > >::type getDisplayPlanePropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCalibrateableTimeDomainsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties2
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getImageFormatProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceFormatsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormatKHR, SurfaceFormatKHRAllocator > >::type getSurfaceFormatsKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceCapabilities2EXT
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilities2EXT >::type getSurfaceCapabilities2EXT(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceFormatsKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormatKHR, SurfaceFormatKHRAllocator > >::type getSurfaceFormatsKHR(vk::SurfaceKHR surface, SurfaceFormatKHRAllocator &surfaceFormatKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFragmentShadingRatesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator > >::type getFragmentShadingRatesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMemoryProperties
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFragmentShadingRatesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator > >::type getFragmentShadingRatesKHR(PhysicalDeviceFragmentShadingRateKHRAllocator &physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures2
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalSemaphorePropertiesKHR
VULKAN_HPP_NODISCARD vk::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(const vk::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalFencePropertiesKHR
VULKAN_HPP_NODISCARD vk::ExternalFenceProperties getExternalFencePropertiesKHR(const vk::PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::createDisplayModeKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayModeKHR >::type createDisplayModeKHR(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceCapabilitiesKHR
VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::createDisplayModeKHR
VULKAN_HPP_NODISCARD Result createDisplayModeKHR(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DisplayModeKHR *pMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::enumerateDeviceLayerProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateDeviceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR
VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, uint32_t *pCounterCount, vk::PerformanceCounterKHR *pCounters, vk::PerformanceCounterDescriptionKHR *pCounterDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties2
void getFormatProperties2(vk::Format format, vk::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR
void getQueueFamilyPerformanceQueryPassesKHR(const vk::QueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::enumerateDeviceExtensionProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getImageFormatProperties
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties >::type getImageFormatProperties(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::createDisplayModeKHRUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DisplayModeKHR, Dispatch > >::type createDisplayModeKHRUnique(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR
VULKAN_HPP_NODISCARD Result getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, vk::VideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSparseImageFormatProperties2KHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMemoryProperties2KHR
void getMemoryProperties2KHR(vk::PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getMultisamplePropertiesEXT
void getMultisamplePropertiesEXT(vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT *pMultisampleProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPropertiesKHR
VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR(uint32_t *pPropertyCount, vk::DisplayPropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceFormats2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, SurfaceFormat2KHRAllocator &surfaceFormat2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlaneCapabilitiesKHR
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalFenceProperties
VULKAN_HPP_NODISCARD vk::ExternalFenceProperties getExternalFenceProperties(const vk::PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getCooperativeMatrixPropertiesNV
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(uint32_t *pPropertyCount, vk::CooperativeMatrixPropertiesNV *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getVideoFormatPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator > >::type getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayModePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator > >::type getDisplayModePropertiesKHR(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures2KHR
void getFeatures2KHR(vk::PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalBufferPropertiesKHR
VULKAN_HPP_NODISCARD vk::ExternalBufferProperties getExternalBufferPropertiesKHR(const vk::PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::operator!=
bool operator!=(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14043

vk::PhysicalDevice::operator==
bool operator==(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14038

vk::PhysicalDevice::getDisplayProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayProperties2KHR, DisplayProperties2KHRAllocator > >::type getDisplayProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getVideoCapabilitiesKHR
VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR *pVideoProfile, vk::VideoCapabilitiesKHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDrmDisplayEXT
VULKAN_HPP_NODISCARD Result getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, vk::DisplayKHR *display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< vk::PerformanceCounterKHR, PerformanceCounterKHRAllocator >, std::vector< vk::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator > > >::type enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCooperativeMatrixPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator > >::type getCooperativeMatrixPropertiesKHR(CooperativeMatrixPropertiesKHRAllocator &cooperativeMatrixPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceCapabilitiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilitiesKHR >::type getSurfaceCapabilitiesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties2KHR
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getExternalSemaphorePropertiesKHR
void getExternalSemaphorePropertiesKHR(const vk::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceCapabilities2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilities2KHR >::type getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties2KHR
void getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, vk::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalSemaphoreProperties
VULKAN_HPP_NODISCARD vk::ExternalSemaphoreProperties getExternalSemaphoreProperties(const vk::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayModeProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator > >::type getDisplayModeProperties2KHR(vk::DisplayKHR display, DisplayModeProperties2KHRAllocator &displayModeProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::acquireDrmDisplayEXT
ResultValueType< void >::type acquireDrmDisplayEXT(int32_t drmFd, vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMemoryProperties2
void getMemoryProperties2(vk::PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator > >::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCooperativeMatrixPropertiesKHR
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR(uint32_t *pPropertyCount, vk::CooperativeMatrixPropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSparseImageFormatProperties2
void getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, vk::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfacePresentModesKHR
VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(vk::SurfaceKHR surface, uint32_t *pPresentModeCount, vk::PresentModeKHR *pPresentModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getCalibrateableTimeDomainsEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsEXT(TimeDomainKHRAllocator &timeDomainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getToolProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolProperties(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMultisamplePropertiesEXT
VULKAN_HPP_NODISCARD vk::MultisamplePropertiesEXT getMultisamplePropertiesEXT(vk::SampleCountFlagBits samples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFormatProperties2(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getVideoFormatPropertiesKHR
VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, vk::VideoFormatPropertiesKHR *pVideoFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getCalibrateableTimeDomainsEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDrmDisplayEXTUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DisplayKHR, Dispatch > >::type getDrmDisplayEXTUnique(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateDeviceLayerProperties
VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(uint32_t *pPropertyCount, vk::LayerProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlaneProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator > >::type getDisplayPlaneProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateDeviceLayerProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateDeviceLayerProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceFormats2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< StructureChain, StructureChainAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getProperties2KHR
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getProperties2KHR
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayModePropertiesKHR
VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(vk::DisplayKHR display, uint32_t *pPropertyCount, vk::DisplayModePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getMemoryProperties2KHR
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getImageFormatProperties
VULKAN_HPP_NODISCARD Result getImageFormatProperties(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayModePropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator > >::type getDisplayModePropertiesKHR(vk::DisplayKHR display, DisplayModePropertiesKHRAllocator &displayModePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator > >::type getDisplayPropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getToolPropertiesEXT
VULKAN_HPP_NODISCARD Result getToolPropertiesEXT(uint32_t *pToolCount, vk::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayModeProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator > >::type getDisplayModeProperties2KHR(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getOpticalFlowImageFormatsNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator > >::type getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV &opticalFlowImageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceFormats2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getImageFormatProperties2
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceCapabilities2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFormatProperties2
VULKAN_HPP_NODISCARD vk::FormatProperties2 getFormatProperties2(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2KHR
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2KHR(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateDeviceExtensionProperties
VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, vk::ExtensionProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getToolProperties
VULKAN_HPP_NODISCARD Result getToolProperties(uint32_t *pToolCount, vk::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2KHR
void getQueueFamilyProperties2KHR(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getMemoryProperties
void getMemoryProperties(vk::PhysicalDeviceMemoryProperties *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getToolPropertiesEXT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolPropertiesEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlaneProperties2KHR
VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(uint32_t *pPropertyCount, vk::DisplayPlaneProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::operator<
bool operator<(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14048

vk::PhysicalDevice::getDisplayProperties2KHR
VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR(uint32_t *pPropertyCount, vk::DisplayProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFeatures2
void getFeatures2(vk::PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceFormats2KHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< StructureChain, StructureChainAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getQueueFamilyProperties
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties, QueueFamilyPropertiesAllocator > getQueueFamilyProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getFeatures
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures getFeatures(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::createDevice
VULKAN_HPP_NODISCARD Result createDevice(const vk::DeviceCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Device *pDevice, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::createDevice
VULKAN_HPP_NODISCARD ResultValueType< vk::Device >::type createDevice(const vk::DeviceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceSupportKHR
VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR(uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32 *pSupported, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::operator=
PhysicalDevice & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14029

vk::PhysicalDevice::getQueueFamilyProperties2
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getQueueFamilyProperties2KHR
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCalibrateableTimeDomainsEXT
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(uint32_t *pTimeDomainCount, vk::TimeDomainKHR *pTimeDomains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties2
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSparseImageFormatProperties
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator > getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getExternalImageFormatPropertiesNV
VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV *pExternalImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getPresentRectanglesKHR
VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR(vk::SurfaceKHR surface, uint32_t *pRectCount, vk::Rect2D *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV
VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(uint32_t *pCombinationCount, vk::FramebufferMixedSamplesCombinationNV *pCombinations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayKHR, DisplayKHRAllocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getVideoCapabilitiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getVideoFormatPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator > >::type getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, VideoFormatPropertiesKHRAllocator &videoFormatPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getExternalBufferPropertiesKHR
void getExternalBufferPropertiesKHR(const vk::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, vk::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getExternalImageFormatPropertiesNV
VULKAN_HPP_NODISCARD ResultValueType< vk::ExternalImageFormatPropertiesNV >::type getExternalImageFormatPropertiesNV(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getImageFormatProperties2KHR
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties2 >::type getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::releaseDisplayEXT
void releaseDisplayEXT(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyProperties
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties, QueueFamilyPropertiesAllocator > getQueueFamilyProperties(QueueFamilyPropertiesAllocator &queueFamilyPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< vk::PerformanceCounterKHR, PerformanceCounterKHRAllocator >, std::vector< vk::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator > > >::type enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, PerformanceCounterKHRAllocator &performanceCounterKHRAllocator, PerformanceCounterDescriptionKHRAllocator &performanceCounterDescriptionKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getToolProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getExternalFenceProperties
void getExternalFenceProperties(const vk::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, vk::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getImageFormatProperties2
VULKAN_HPP_NODISCARD Result getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, vk::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getDisplayModeProperties2KHR
VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(vk::DisplayKHR display, uint32_t *pPropertyCount, vk::DisplayModeProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getImageFormatProperties2
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties2 >::type getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getMemoryProperties2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getProperties
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties getProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFragmentShadingRatesKHR
VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(uint32_t *pFragmentShadingRateCount, vk::PhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getFormatProperties
VULKAN_HPP_NODISCARD vk::FormatProperties getFormatProperties(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getSurfaceSupportKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::Bool32 >::type getSurfaceSupportKHR(uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getCooperativeMatrixPropertiesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator > >::type getCooperativeMatrixPropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayKHR, DisplayKHRAllocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, DisplayKHRAllocator &displayKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getDisplayPlaneCapabilitiesKHR
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayPlaneCapabilitiesKHR >::type getDisplayPlaneCapabilitiesKHR(vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getProperties2
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getProperties2KHR
void getProperties2KHR(vk::PhysicalDeviceProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR
VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(const vk::QueryPoolPerformanceCreateInfoKHR &performanceQueryCreateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PhysicalDevice::getOpticalFlowImageFormatsNV
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator > >::type getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV &opticalFlowImageFormatInfo, OpticalFlowImageFormatPropertiesNVAllocator &opticalFlowImageFormatPropertiesNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfacePresentModesKHR
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PresentModeKHR, PresentModeKHRAllocator > >::type getSurfacePresentModesKHR(vk::SurfaceKHR surface, PresentModeKHRAllocator &presentModeKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::PhysicalDevice::getSurfaceFormats2KHR
VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, vk::SurfaceFormat2KHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::PipelineCache
Definition: vulkan_handles.hpp:7141

vk::PipelineCache::CType
VkPipelineCache CType
Definition: vulkan_handles.hpp:7143

vk::PipelineCache::operator=
PipelineCache & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7165

vk::PipelineCache::NativeType
VkPipelineCache NativeType
Definition: vulkan_handles.hpp:7144

vk::PipelineCache::operator==
bool operator==(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7174

vk::PipelineCache::operator!=
bool operator!=(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7179

vk::PipelineCache::operator<
bool operator<(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7184

vk::PipelineCache::PipelineCache
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7155

vk::PipelineCache::PipelineCache
VULKAN_HPP_CONSTEXPR PipelineCache()=default

vk::PipelineCache::PipelineCache
VULKAN_HPP_CONSTEXPR PipelineCache(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7153

vk::PipelineCache::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7200

vk::PipelineLayout
Definition: vulkan_handles.hpp:3222

vk::PipelineLayout::PipelineLayout
VULKAN_HPP_CONSTEXPR PipelineLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3234

vk::PipelineLayout::operator!=
bool operator!=(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3260

vk::PipelineLayout::NativeType
VkPipelineLayout NativeType
Definition: vulkan_handles.hpp:3225

vk::PipelineLayout::operator=
PipelineLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3246

vk::PipelineLayout::operator<
bool operator<(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3265

vk::PipelineLayout::PipelineLayout
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3236

vk::PipelineLayout::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3281

vk::PipelineLayout::PipelineLayout
VULKAN_HPP_CONSTEXPR PipelineLayout()=default

vk::PipelineLayout::operator==
bool operator==(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3255

vk::PipelineLayout::CType
VkPipelineLayout CType
Definition: vulkan_handles.hpp:3224

vk::Pipeline
Definition: vulkan_handles.hpp:3483

vk::Pipeline::operator<
bool operator<(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3526

vk::Pipeline::NativeType
VkPipeline NativeType
Definition: vulkan_handles.hpp:3486

vk::Pipeline::CType
VkPipeline CType
Definition: vulkan_handles.hpp:3485

vk::Pipeline::Pipeline
VULKAN_HPP_CONSTEXPR Pipeline(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3495

vk::Pipeline::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3542

vk::Pipeline::operator!=
bool operator!=(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3521

vk::Pipeline::Pipeline
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3497

vk::Pipeline::operator==
bool operator==(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3516

vk::Pipeline::Pipeline
VULKAN_HPP_CONSTEXPR Pipeline()=default

vk::Pipeline::operator=
Pipeline & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3507

vk::PoolFree
Definition: vulkan.hpp:6075

vk::PrivateDataSlot
Definition: vulkan_handles.hpp:7928

vk::PrivateDataSlot::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7987

vk::PrivateDataSlot::NativeType
VkPrivateDataSlot NativeType
Definition: vulkan_handles.hpp:7931

vk::PrivateDataSlot::operator!=
bool operator!=(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7966

vk::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7942

vk::PrivateDataSlot::operator=
PrivateDataSlot & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7952

vk::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_CONSTEXPR PrivateDataSlot()=default

vk::PrivateDataSlot::operator==
bool operator==(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7961

vk::PrivateDataSlot::PrivateDataSlot
VULKAN_HPP_CONSTEXPR PrivateDataSlot(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7940

vk::PrivateDataSlot::operator<
bool operator<(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7971

vk::PrivateDataSlot::CType
VkPrivateDataSlot CType
Definition: vulkan_handles.hpp:7930

vk::QueryPool
Definition: vulkan_handles.hpp:3048

vk::QueryPool::QueryPool
VULKAN_HPP_CONSTEXPR QueryPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3060

vk::QueryPool::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3107

vk::QueryPool::QueryPool
VULKAN_HPP_CONSTEXPR QueryPool()=default

vk::QueryPool::operator<
bool operator<(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3091

vk::QueryPool::operator=
QueryPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3072

vk::QueryPool::QueryPool
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3062

vk::QueryPool::NativeType
VkQueryPool NativeType
Definition: vulkan_handles.hpp:3051

vk::QueryPool::CType
VkQueryPool CType
Definition: vulkan_handles.hpp:3050

vk::QueryPool::operator==
bool operator==(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3081

vk::QueryPool::operator!=
bool operator!=(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3086

vk::Queue
Definition: vulkan_handles.hpp:8537

vk::Queue::bindSparse
VULKAN_HPP_NODISCARD Result bindSparse(uint32_t bindInfoCount, const vk::BindSparseInfo *pBindInfo, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::setPerformanceConfigurationINTEL
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceConfigurationINTEL(vk::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::operator=
Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8553

vk::Queue::NativeType
VkQueue NativeType
Definition: vulkan_handles.hpp:8540

vk::Queue::bindSparse
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindSparse(vk::ArrayProxy< const vk::BindSparseInfo > const &bindInfo, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::getCheckpointData2NV
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointData2NV, CheckpointData2NVAllocator > getCheckpointData2NV(CheckpointData2NVAllocator &checkpointData2NVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::getCheckpointData2NV
void getCheckpointData2NV(uint32_t *pCheckpointDataCount, vk::CheckpointData2NV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::notifyOutOfBandNV
void notifyOutOfBandNV(const vk::OutOfBandQueueTypeInfoNV &queueTypeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::getCheckpointDataNV
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointDataNV, CheckpointDataNVAllocator > getCheckpointDataNV(CheckpointDataNVAllocator &checkpointDataNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::Queue
VULKAN_HPP_CONSTEXPR Queue()=default

vk::Queue::submit2
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit2(vk::ArrayProxy< const vk::SubmitInfo2 > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::presentKHR
VULKAN_HPP_NODISCARD vk::Result presentKHR(const vk::PresentInfoKHR &presentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::insertDebugUtilsLabelEXT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::CType
VkQueue CType
Definition: vulkan_handles.hpp:8539

vk::Queue::operator!=
bool operator!=(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8573

vk::Queue::presentKHR
VULKAN_HPP_NODISCARD Result presentKHR(const vk::PresentInfoKHR *pPresentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::submit2KHR
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit2KHR(vk::ArrayProxy< const vk::SubmitInfo2 > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::operator<
bool operator<(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8578

vk::Queue::getCheckpointDataNV
void getCheckpointDataNV(uint32_t *pCheckpointDataCount, vk::CheckpointDataNV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::getCheckpointDataNV
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointDataNV, CheckpointDataNVAllocator > getCheckpointDataNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::notifyOutOfBandNV
void notifyOutOfBandNV(const vk::OutOfBandQueueTypeInfoNV *pQueueTypeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::Queue
VULKAN_HPP_CONSTEXPR Queue(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8549

vk::Queue::getCheckpointData2NV
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointData2NV, CheckpointData2NVAllocator > getCheckpointData2NV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::submit
VULKAN_HPP_NODISCARD Result submit(uint32_t submitCount, const vk::SubmitInfo *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::submit2
VULKAN_HPP_NODISCARD Result submit2(uint32_t submitCount, const vk::SubmitInfo2 *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::operator=
Queue & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8559

vk::Queue::beginDebugUtilsLabelEXT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::Queue
Queue(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8551

vk::Queue::operator==
bool operator==(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8568

vk::Queue::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8754

vk::Queue::submit2KHR
VULKAN_HPP_NODISCARD Result submit2KHR(uint32_t submitCount, const vk::SubmitInfo2 *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::endDebugUtilsLabelEXT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT

vk::Queue::waitIdle
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::Queue::submit
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit(vk::ArrayProxy< const vk::SubmitInfo > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const

vk::RenderPass
Definition: vulkan_handles.hpp:8011

vk::RenderPass::RenderPass
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8025

vk::RenderPass::NativeType
VkRenderPass NativeType
Definition: vulkan_handles.hpp:8014

vk::RenderPass::CType
VkRenderPass CType
Definition: vulkan_handles.hpp:8013

vk::RenderPass::RenderPass
VULKAN_HPP_CONSTEXPR RenderPass(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8023

vk::RenderPass::operator<
bool operator<(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8054

vk::RenderPass::operator=
RenderPass & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8035

vk::RenderPass::operator==
bool operator==(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8044

vk::RenderPass::RenderPass
VULKAN_HPP_CONSTEXPR RenderPass()=default

vk::RenderPass::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8070

vk::RenderPass::operator!=
bool operator!=(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8049

vk::SamplerYcbcrConversion
Definition: vulkan_handles.hpp:8185

vk::SamplerYcbcrConversion::operator==
bool operator==(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8221

vk::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8199

vk::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8197

vk::SamplerYcbcrConversion::SamplerYcbcrConversion
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()=default

vk::SamplerYcbcrConversion::NativeType
VkSamplerYcbcrConversion NativeType
Definition: vulkan_handles.hpp:8188

vk::SamplerYcbcrConversion::operator<
bool operator<(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8231

vk::SamplerYcbcrConversion::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8247

vk::SamplerYcbcrConversion::operator=
SamplerYcbcrConversion & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8212

vk::SamplerYcbcrConversion::CType
VkSamplerYcbcrConversion CType
Definition: vulkan_handles.hpp:8187

vk::SamplerYcbcrConversion::operator!=
bool operator!=(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8226

vk::Sampler
Definition: vulkan_handles.hpp:8098

vk::Sampler::CType
VkSampler CType
Definition: vulkan_handles.hpp:8100

vk::Sampler::operator=
Sampler & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8122

vk::Sampler::Sampler
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8112

vk::Sampler::NativeType
VkSampler NativeType
Definition: vulkan_handles.hpp:8101

vk::Sampler::operator==
bool operator==(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8131

vk::Sampler::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8157

vk::Sampler::operator<
bool operator<(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8141

vk::Sampler::Sampler
VULKAN_HPP_CONSTEXPR Sampler()=default

vk::Sampler::operator!=
bool operator!=(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8136

vk::Sampler::Sampler
VULKAN_HPP_CONSTEXPR Sampler(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8110

vk::Semaphore
Definition: vulkan_handles.hpp:2790

vk::Semaphore::NativeType
VkSemaphore NativeType
Definition: vulkan_handles.hpp:2793

vk::Semaphore::CType
VkSemaphore CType
Definition: vulkan_handles.hpp:2792

vk::Semaphore::operator!=
bool operator!=(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2828

vk::Semaphore::operator<
bool operator<(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2833

vk::Semaphore::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2849

vk::Semaphore::Semaphore
VULKAN_HPP_CONSTEXPR Semaphore(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2802

vk::Semaphore::Semaphore
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2804

vk::Semaphore::Semaphore
VULKAN_HPP_CONSTEXPR Semaphore()=default

vk::Semaphore::operator=
Semaphore & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2814

vk::Semaphore::operator==
bool operator==(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2823

vk::ShaderEXT
Definition: vulkan_handles.hpp:3570

vk::ShaderEXT::operator<
bool operator<(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3613

vk::ShaderEXT::ShaderEXT
VULKAN_HPP_CONSTEXPR ShaderEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3582

vk::ShaderEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3629

vk::ShaderEXT::ShaderEXT
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT(VkShaderEXT shaderEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3584

vk::ShaderEXT::CType
VkShaderEXT CType
Definition: vulkan_handles.hpp:3572

vk::ShaderEXT::NativeType
VkShaderEXT NativeType
Definition: vulkan_handles.hpp:3573

vk::ShaderEXT::ShaderEXT
VULKAN_HPP_CONSTEXPR ShaderEXT()=default

vk::ShaderEXT::operator=
ShaderEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3594

vk::ShaderEXT::operator!=
bool operator!=(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3608

vk::ShaderEXT::operator==
bool operator==(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3603

vk::ShaderModule
Definition: vulkan_handles.hpp:8277

vk::ShaderModule::operator=
ShaderModule & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8301

vk::ShaderModule::ShaderModule
VULKAN_HPP_CONSTEXPR ShaderModule()=default

vk::ShaderModule::operator==
bool operator==(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8310

vk::ShaderModule::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8336

vk::ShaderModule::CType
VkShaderModule CType
Definition: vulkan_handles.hpp:8279

vk::ShaderModule::operator<
bool operator<(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8320

vk::ShaderModule::operator!=
bool operator!=(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8315

vk::ShaderModule::ShaderModule
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8291

vk::ShaderModule::NativeType
VkShaderModule NativeType
Definition: vulkan_handles.hpp:8280

vk::ShaderModule::ShaderModule
VULKAN_HPP_CONSTEXPR ShaderModule(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8289

vk::StructureChain
Definition: vulkan.hpp:654

vk::SurfaceKHR
Definition: vulkan_handles.hpp:2355

vk::SurfaceKHR::operator!=
bool operator!=(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2393

vk::SurfaceKHR::NativeType
VkSurfaceKHR NativeType
Definition: vulkan_handles.hpp:2358

vk::SurfaceKHR::SurfaceKHR
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2369

vk::SurfaceKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2414

vk::SurfaceKHR::operator=
SurfaceKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2379

vk::SurfaceKHR::SurfaceKHR
VULKAN_HPP_CONSTEXPR SurfaceKHR()=default

vk::SurfaceKHR::operator<
bool operator<(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2398

vk::SurfaceKHR::operator==
bool operator==(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2388

vk::SurfaceKHR::SurfaceKHR
VULKAN_HPP_CONSTEXPR SurfaceKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2367

vk::SurfaceKHR::CType
VkSurfaceKHR CType
Definition: vulkan_handles.hpp:2357

vk::SwapchainKHR
Definition: vulkan_handles.hpp:2703

vk::SwapchainKHR::SwapchainKHR
VULKAN_HPP_CONSTEXPR SwapchainKHR()=default

vk::SwapchainKHR::operator=
SwapchainKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2727

vk::SwapchainKHR::SwapchainKHR
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2717

vk::SwapchainKHR::NativeType
VkSwapchainKHR NativeType
Definition: vulkan_handles.hpp:2706

vk::SwapchainKHR::operator==
bool operator==(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2736

vk::SwapchainKHR::CType
VkSwapchainKHR CType
Definition: vulkan_handles.hpp:2705

vk::SwapchainKHR::SwapchainKHR
VULKAN_HPP_CONSTEXPR SwapchainKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2715

vk::SwapchainKHR::operator!=
bool operator!=(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2741

vk::SwapchainKHR::operator<
bool operator<(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2746

vk::SwapchainKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2762

vk::UniqueHandleTraits
Definition: vulkan.hpp:873

vk::UniqueHandle
Definition: vulkan.hpp:877

vk::ValidationCacheEXT
Definition: vulkan_handles.hpp:8364

vk::ValidationCacheEXT::operator=
ValidationCacheEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8390

vk::ValidationCacheEXT::CType
VkValidationCacheEXT CType
Definition: vulkan_handles.hpp:8366

vk::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()=default

vk::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8376

vk::ValidationCacheEXT::operator==
bool operator==(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8399

vk::ValidationCacheEXT::ValidationCacheEXT
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8378

vk::ValidationCacheEXT::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8425

vk::ValidationCacheEXT::operator<
bool operator<(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8409

vk::ValidationCacheEXT::NativeType
VkValidationCacheEXT NativeType
Definition: vulkan_handles.hpp:8367

vk::ValidationCacheEXT::operator!=
bool operator!=(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8404

vk::VideoSessionKHR
Definition: vulkan_handles.hpp:6710

vk::VideoSessionKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6769

vk::VideoSessionKHR::operator==
bool operator==(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6743

vk::VideoSessionKHR::operator!=
bool operator!=(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6748

vk::VideoSessionKHR::VideoSessionKHR
VULKAN_HPP_CONSTEXPR VideoSessionKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6722

vk::VideoSessionKHR::VideoSessionKHR
VULKAN_HPP_CONSTEXPR VideoSessionKHR()=default

vk::VideoSessionKHR::operator=
VideoSessionKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6734

vk::VideoSessionKHR::operator<
bool operator<(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6753

vk::VideoSessionKHR::VideoSessionKHR
VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR(VkVideoSessionKHR videoSessionKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6724

vk::VideoSessionKHR::CType
VkVideoSessionKHR CType
Definition: vulkan_handles.hpp:6712

vk::VideoSessionKHR::NativeType
VkVideoSessionKHR NativeType
Definition: vulkan_handles.hpp:6713

vk::VideoSessionParametersKHR
Definition: vulkan_handles.hpp:8453

vk::VideoSessionParametersKHR::operator<
bool operator<(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8499

vk::VideoSessionParametersKHR::NativeType
VkVideoSessionParametersKHR NativeType
Definition: vulkan_handles.hpp:8456

vk::VideoSessionParametersKHR::operator!=
bool operator!=(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8494

vk::VideoSessionParametersKHR::VideoSessionParametersKHR
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8465

vk::VideoSessionParametersKHR::CType
VkVideoSessionParametersKHR CType
Definition: vulkan_handles.hpp:8455

vk::VideoSessionParametersKHR::operator==
bool operator==(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8489

vk::VideoSessionParametersKHR::VideoSessionParametersKHR
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR()=default

vk::VideoSessionParametersKHR::VideoSessionParametersKHR
VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8467

vk::VideoSessionParametersKHR::operator=
VideoSessionParametersKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8480

vk::VideoSessionParametersKHR::operator!
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8515

vk::SampleCountFlagBits
SampleCountFlagBits
Definition: vulkan_enums.hpp:2057

vk::FrontFace
FrontFace
Definition: vulkan_enums.hpp:2803

vk::CommandBufferResetFlags
Flags< CommandBufferResetFlagBits > CommandBufferResetFlags
Definition: vulkan_enums.hpp:3496

vk::SurfaceCounterFlagBitsEXT
SurfaceCounterFlagBitsEXT
Definition: vulkan_enums.hpp:5272

vk::SampleMask
uint32_t SampleMask
Definition: vulkan.hpp:6124

vk::ImageTiling
ImageTiling
Definition: vulkan_enums.hpp:1909

vk::CullModeFlags
Flags< CullModeFlagBits > CullModeFlags
Definition: vulkan_enums.hpp:2701

vk::PrimitiveTopology
PrimitiveTopology
Definition: vulkan_enums.hpp:2923

vk::DebugUtilsMessageTypeFlagsEXT
Flags< DebugUtilsMessageTypeFlagBitsEXT > DebugUtilsMessageTypeFlagsEXT
Definition: vulkan_enums.hpp:5518

vk::QueryType
QueryType
Definition: vulkan_enums.hpp:2343

vk::AccelerationStructureBuildTypeKHR
AccelerationStructureBuildTypeKHR
Definition: vulkan_enums.hpp:5590

vk::ImageCreateFlags
Flags< ImageCreateFlagBits > ImageCreateFlags
Definition: vulkan_enums.hpp:1892

vk::enumerateInstanceVersion
VULKAN_HPP_NODISCARD ResultValueType< uint32_t >::type enumerateInstanceVersion(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)

vk::OpticalFlowSessionBindingPointNV
OpticalFlowSessionBindingPointNV
Definition: vulkan_enums.hpp:6851

vk::DeviceAddress
uint64_t DeviceAddress
Definition: vulkan.hpp:6121

vk::ImageUsageFlags
Flags< ImageUsageFlagBits > ImageUsageFlags
Definition: vulkan_enums.hpp:1948

vk::enumerateInstanceExtensionProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateInstanceExtensionProperties(Optional< const std::string > layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)

vk::ColorComponentFlags
Flags< ColorComponentFlagBits > ColorComponentFlags
Definition: vulkan_enums.hpp:2671

vk::enumerateInstanceLayerProperties
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateInstanceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)

vk::ImageAspectFlags
Flags< ImageAspectFlagBits > ImageAspectFlags
Definition: vulkan_enums.hpp:2202

vk::PipelineBindPoint
PipelineBindPoint
Definition: vulkan_enums.hpp:3401

vk::ImageLayout
ImageLayout
Definition: vulkan_enums.hpp:2477

vk::CommandPoolResetFlags
Flags< CommandPoolResetFlagBits > CommandPoolResetFlags
Definition: vulkan_enums.hpp:3476

vk::DiscardRectangleModeEXT
DiscardRectangleModeEXT
Definition: vulkan_enums.hpp:5334

vk::DescriptorType
DescriptorType
Definition: vulkan_enums.hpp:3244

vk::MemoryMapFlags
Flags< MemoryMapFlagBits > MemoryMapFlags
Definition: vulkan_enums.hpp:2173

vk::debugReportObjectType
VULKAN_HPP_INLINE vk::DebugReportObjectTypeEXT debugReportObjectType(vk::ObjectType objectType)
Definition: vulkan_enums.hpp:7208

vk::QueryControlFlags
Flags< QueryControlFlagBits > QueryControlFlags
Definition: vulkan_enums.hpp:3527

vk::ExternalMemoryHandleTypeFlagsNV
Flags< ExternalMemoryHandleTypeFlagBitsNV > ExternalMemoryHandleTypeFlagsNV
Definition: vulkan_enums.hpp:5182

vk::CoverageModulationModeNV
CoverageModulationModeNV
Definition: vulkan_enums.hpp:5745

vk::PerformanceParameterTypeINTEL
PerformanceParameterTypeINTEL
Definition: vulkan_enums.hpp:5874

vk::PipelineStageFlags2
Flags< PipelineStageFlagBits2 > PipelineStageFlags2
Definition: vulkan_enums.hpp:4134

vk::ProvokingVertexModeEXT
ProvokingVertexModeEXT
Definition: vulkan_enums.hpp:5995

vk::TimeDomainKHR
TimeDomainKHR
Definition: vulkan_enums.hpp:7151

vk::LineRasterizationModeEXT
LineRasterizationModeEXT
Definition: vulkan_enums.hpp:6030

vk::DebugReportObjectTypeEXT
DebugReportObjectTypeEXT
Definition: vulkan_enums.hpp:4618

vk::AccelerationStructureCompatibilityKHR
AccelerationStructureCompatibilityKHR
Definition: vulkan_enums.hpp:5695

vk::DependencyFlags
Flags< DependencyFlagBits > DependencyFlags
Definition: vulkan_enums.hpp:3375

vk::ShaderStageFlags
Flags< ShaderStageFlagBits > ShaderStageFlags
Definition: vulkan_enums.hpp:2967

vk::FragmentShadingRateCombinerOpKHR
FragmentShadingRateCombinerOpKHR
Definition: vulkan_enums.hpp:5925

vk::DebugReportFlagsEXT
Flags< DebugReportFlagBitsEXT > DebugReportFlagsEXT
Definition: vulkan_enums.hpp:4606

vk::ShaderStageFlagBits
ShaderStageFlagBits
Definition: vulkan_enums.hpp:2938

vk::CoarseSampleOrderTypeNV
CoarseSampleOrderTypeNV
Definition: vulkan_enums.hpp:5804

vk::DebugUtilsMessageSeverityFlagBitsEXT
DebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_enums.hpp:5492

vk::PeerMemoryFeatureFlags
Flags< PeerMemoryFeatureFlagBits > PeerMemoryFeatureFlags
Definition: vulkan_enums.hpp:3606

vk::TessellationDomainOrigin
TessellationDomainOrigin
Definition: vulkan_enums.hpp:3658

vk::CopyAccelerationStructureModeKHR
CopyAccelerationStructureModeKHR
Definition: vulkan_enums.hpp:5678

vk::ExternalMemoryHandleTypeFlagBits
ExternalMemoryHandleTypeFlagBits
Definition: vulkan_enums.hpp:3710

vk::PipelineStageFlagBits
PipelineStageFlagBits
Definition: vulkan_enums.hpp:2115

vk::Bool32
uint32_t Bool32
Definition: vulkan.hpp:6120

vk::QueryResultFlags
Flags< QueryResultFlagBits > QueryResultFlags
Definition: vulkan_enums.hpp:2331

vk::Filter
Filter
Definition: vulkan_enums.hpp:3152

vk::ImageType
ImageType
Definition: vulkan_enums.hpp:1916

vk::LogicOp
LogicOp
Definition: vulkan_enums.hpp:2809

vk::ConservativeRasterizationModeEXT
ConservativeRasterizationModeEXT
Definition: vulkan_enums.hpp:5355

vk::PipelineStageFlags
Flags< PipelineStageFlagBits > PipelineStageFlags
Definition: vulkan_enums.hpp:2151

vk::SubpassContents
SubpassContents
Definition: vulkan_enums.hpp:3564

vk::PolygonMode
PolygonMode
Definition: vulkan_enums.hpp:2915

vk::DeviceSize
uint64_t DeviceSize
Definition: vulkan.hpp:6122

vk::Result
Result
Definition: vulkan_enums.hpp:231

vk::FragmentShadingRateNV
FragmentShadingRateNV
Definition: vulkan_enums.hpp:6395

vk::CoverageReductionModeNV
CoverageReductionModeNV
Definition: vulkan_enums.hpp:5974

vk::MemoryRequirements2KHR
MemoryRequirements2 MemoryRequirements2KHR
Definition: vulkan_handles.hpp:167

vk::createInstanceUnique
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Instance, Dispatch > >::type createInstanceUnique(const vk::InstanceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)

vk::createInstance
VULKAN_HPP_NODISCARD ResultValueType< vk::Instance >::type createInstance(const vk::InstanceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)

vk::CompareOp
CompareOp
Definition: vulkan_enums.hpp:2682

vk::operator<
bool operator<(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:210

vk::PresentModeKHR
PresentModeKHR
Definition: vulkan_enums.hpp:4374

vk::IndexType
IndexType
Definition: vulkan_enums.hpp:3537

vk::PipelineInfoEXT
PipelineInfoKHR PipelineInfoEXT
Definition: vulkan_handles.hpp:1143

vk::DeviceGroupPresentModeFlagsKHR
Flags< DeviceGroupPresentModeFlagBitsKHR > DeviceGroupPresentModeFlagsKHR
Definition: vulkan_enums.hpp:4452

vk::CommandPoolTrimFlags
Flags< CommandPoolTrimFlagBits > CommandPoolTrimFlags
Definition: vulkan_enums.hpp:3640

vk::ObjectType
ObjectType
Definition: vulkan_enums.hpp:1412

vk::Format
Format
Definition: vulkan_enums.hpp:1485

vk::StencilFaceFlags
Flags< StencilFaceFlagBits > StencilFaceFlags
Definition: vulkan_enums.hpp:3553

vk::RemoteAddressNV
void * RemoteAddressNV
Definition: vulkan.hpp:6123

vk::DescriptorPoolResetFlags
Flags< DescriptorPoolResetFlagBits > DescriptorPoolResetFlags
Definition: vulkan_enums.hpp:3270

vk::ShaderInfoTypeAMD
ShaderInfoTypeAMD
Definition: vulkan_enums.hpp:5149

vk::ShaderGroupShaderKHR
ShaderGroupShaderKHR
Definition: vulkan_enums.hpp:5735

vk::StencilOp
StencilOp
Definition: vulkan_enums.hpp:2982

vk::AabbPositionsKHR
Definition: vulkan_structs.hpp:21

vk::AccelerationStructureBuildGeometryInfoKHR
Definition: vulkan_structs.hpp:723

vk::AccelerationStructureBuildRangeInfoKHR
Definition: vulkan_structs.hpp:949

vk::AccelerationStructureBuildSizesInfoKHR
Definition: vulkan_structs.hpp:1055

vk::AccelerationStructureCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:1178

vk::AccelerationStructureCreateInfoKHR
Definition: vulkan_structs.hpp:1292

vk::AccelerationStructureCreateInfoNV
Definition: vulkan_structs.hpp:2150

vk::AccelerationStructureDeviceAddressInfoKHR
Definition: vulkan_structs.hpp:2259

vk::AccelerationStructureGeometryAabbsDataKHR
Definition: vulkan_structs.hpp:329

vk::AccelerationStructureGeometryInstancesDataKHR
Definition: vulkan_structs.hpp:421

vk::AccelerationStructureGeometryKHR
Definition: vulkan_structs.hpp:577

vk::AccelerationStructureGeometryMotionTrianglesDataNV
Definition: vulkan_structs.hpp:2357

vk::AccelerationStructureGeometryTrianglesDataKHR
Definition: vulkan_structs.hpp:182

vk::AccelerationStructureInfoNV
Definition: vulkan_structs.hpp:1984

vk::AccelerationStructureInstanceKHR
Definition: vulkan_structs.hpp:2513

vk::AccelerationStructureMatrixMotionInstanceNV
Definition: vulkan_structs.hpp:2646

vk::AccelerationStructureMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:2791

vk::AccelerationStructureMotionInfoNV
Definition: vulkan_structs.hpp:2904

vk::AccelerationStructureMotionInstanceNV
Definition: vulkan_structs.hpp:3450

vk::AccelerationStructureSRTMotionInstanceNV
Definition: vulkan_structs.hpp:3241

vk::AccelerationStructureTrianglesOpacityMicromapEXT
Definition: vulkan_structs.hpp:3961

vk::AccelerationStructureVersionInfoKHR
Definition: vulkan_structs.hpp:4171

vk::AcquireNextImageInfoKHR
Definition: vulkan_structs.hpp:4267

vk::AcquireProfilingLockInfoKHR
Definition: vulkan_structs.hpp:4407

vk::AmigoProfilingSubmitInfoSEC
Definition: vulkan_structs.hpp:4637

vk::AttachmentDescription2
Definition: vulkan_structs.hpp:5792

vk::AttachmentDescriptionStencilLayout
Definition: vulkan_structs.hpp:5975

vk::AttachmentReference2
Definition: vulkan_structs.hpp:6174

vk::AttachmentReferenceStencilLayout
Definition: vulkan_structs.hpp:6296

vk::AttachmentSampleCountInfoAMD
Definition: vulkan_structs.hpp:6395

vk::AttachmentSampleLocationsEXT
Definition: vulkan_structs.hpp:6868

vk::BindAccelerationStructureMemoryInfoNV
Definition: vulkan_structs.hpp:7112

vk::BindBufferMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:7279

vk::BindBufferMemoryInfo
Definition: vulkan_structs.hpp:7404

vk::BindDescriptorBufferEmbeddedSamplersInfoEXT
Definition: vulkan_structs.hpp:7525

vk::BindDescriptorSetsInfoKHR
Definition: vulkan_structs.hpp:7645

vk::BindImageMemoryDeviceGroupInfo
Definition: vulkan_structs.hpp:8010

vk::BindImageMemoryInfo
Definition: vulkan_structs.hpp:8176

vk::BindImageMemorySwapchainInfoKHR
Definition: vulkan_structs.hpp:8296

vk::BindImagePlaneMemoryInfo
Definition: vulkan_structs.hpp:8402

vk::BindIndexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:8501

vk::BindMemoryStatusKHR
Definition: vulkan_structs.hpp:8598

vk::BindPipelineIndirectCommandNV
Definition: vulkan_structs.hpp:8693

vk::BindShaderGroupIndirectCommandNV
Definition: vulkan_structs.hpp:8771

vk::BindVertexBufferIndirectCommandNV
Definition: vulkan_structs.hpp:9985

vk::BindVideoSessionMemoryInfoKHR
Definition: vulkan_structs.hpp:10081

vk::BlitImageCubicWeightsInfoQCOM
Definition: vulkan_structs.hpp:10211

vk::BlitImageInfo2
Definition: vulkan_structs.hpp:10543

vk::BufferCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:10732

vk::BufferCopy2
Definition: vulkan_structs.hpp:12009

vk::BufferDeviceAddressCreateInfoEXT
Definition: vulkan_structs.hpp:12127

vk::BufferDeviceAddressInfo
Definition: vulkan_structs.hpp:12224

vk::BufferImageCopy2
Definition: vulkan_structs.hpp:12449

vk::BufferMemoryBarrier2
Definition: vulkan_structs.hpp:12759

vk::BufferMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:12942

vk::BufferOpaqueCaptureAddressCreateInfo
Definition: vulkan_structs.hpp:13040

vk::BufferUsageFlags2CreateInfoKHR
Definition: vulkan_structs.hpp:13138

vk::CalibratedTimestampInfoKHR
Definition: vulkan_structs.hpp:13375

vk::CheckpointData2NV
Definition: vulkan_structs.hpp:13474

vk::CheckpointDataNV
Definition: vulkan_structs.hpp:13556

vk::CoarseSampleLocationNV
Definition: vulkan_structs.hpp:13996

vk::CoarseSampleOrderCustomNV
Definition: vulkan_structs.hpp:14090

vk::ColorBlendAdvancedEXT
Definition: vulkan_structs.hpp:14223

vk::ColorBlendEquationEXT
Definition: vulkan_structs.hpp:14342

vk::CommandBufferInheritanceConditionalRenderingInfoEXT
Definition: vulkan_structs.hpp:14853

vk::CommandBufferInheritanceRenderPassTransformInfoQCOM
Definition: vulkan_structs.hpp:14953

vk::CommandBufferInheritanceRenderingInfo
Definition: vulkan_structs.hpp:15067

vk::CommandBufferInheritanceViewportScissorInfoNV
Definition: vulkan_structs.hpp:15384

vk::CommandBufferSubmitInfo
Definition: vulkan_structs.hpp:15507

vk::ComputePipelineIndirectBufferInfoNV
Definition: vulkan_structs.hpp:16245

vk::ConditionalRenderingBeginInfoEXT
Definition: vulkan_structs.hpp:16366

vk::ConformanceVersion
Definition: vulkan_structs.hpp:16485

vk::CooperativeMatrixPropertiesKHR
Definition: vulkan_structs.hpp:16586

vk::CooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:16768

vk::CopyAccelerationStructureInfoKHR
Definition: vulkan_structs.hpp:16938

vk::CopyAccelerationStructureToMemoryInfoKHR
Definition: vulkan_structs.hpp:17058

vk::CopyBufferInfo2
Definition: vulkan_structs.hpp:17161

vk::CopyBufferToImageInfo2
Definition: vulkan_structs.hpp:17309

vk::CopyCommandTransformInfoQCOM
Definition: vulkan_structs.hpp:17477

vk::CopyImageInfo2
Definition: vulkan_structs.hpp:17872

vk::CopyImageToBufferInfo2
Definition: vulkan_structs.hpp:18048

vk::CopyImageToImageInfoEXT
Definition: vulkan_structs.hpp:18216

vk::CopyImageToMemoryInfoEXT
Definition: vulkan_structs.hpp:18559

vk::CopyMemoryIndirectCommandNV
Definition: vulkan_structs.hpp:18725

vk::CopyMemoryToAccelerationStructureInfoKHR
Definition: vulkan_structs.hpp:18821

vk::CopyMemoryToImageIndirectCommandNV
Definition: vulkan_structs.hpp:18925

vk::CopyMemoryToImageInfoEXT
Definition: vulkan_structs.hpp:19207

vk::CopyMemoryToMicromapInfoEXT
Definition: vulkan_structs.hpp:19373

vk::CopyMicromapInfoEXT
Definition: vulkan_structs.hpp:19474

vk::CopyMicromapToMemoryInfoEXT
Definition: vulkan_structs.hpp:19592

vk::CppType
Definition: vulkan_enums.hpp:221

vk::CuFunctionCreateInfoNVX
Definition: vulkan_structs.hpp:19693

vk::CuLaunchInfoNVX
Definition: vulkan_structs.hpp:19807

vk::CuModuleCreateInfoNVX
Definition: vulkan_structs.hpp:20064

vk::DebugMarkerMarkerInfoEXT
Definition: vulkan_structs.hpp:20851

vk::DebugMarkerObjectNameInfoEXT
Definition: vulkan_structs.hpp:20966

vk::DebugMarkerObjectTagInfoEXT
Definition: vulkan_structs.hpp:21098

vk::DebugReportCallbackCreateInfoEXT
Definition: vulkan_structs.hpp:21261

vk::DebugUtilsLabelEXT
Definition: vulkan_structs.hpp:21376

vk::DebugUtilsMessengerCallbackDataEXT
Definition: vulkan_structs.hpp:21616

vk::DebugUtilsMessengerCreateInfoEXT
Definition: vulkan_structs.hpp:21895

vk::DebugUtilsObjectNameInfoEXT
Definition: vulkan_structs.hpp:21488

vk::DebugUtilsObjectTagInfoEXT
Definition: vulkan_structs.hpp:22033

vk::DecompressMemoryRegionNV
Definition: vulkan_structs.hpp:22200

vk::DedicatedAllocationBufferCreateInfoNV
Definition: vulkan_structs.hpp:22320

vk::DedicatedAllocationImageCreateInfoNV
Definition: vulkan_structs.hpp:22418

vk::DedicatedAllocationMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:22516

vk::DependencyInfo
Definition: vulkan_structs.hpp:23071

vk::DepthBiasInfoEXT
Definition: vulkan_structs.hpp:23290

vk::DepthBiasRepresentationInfoEXT
Definition: vulkan_structs.hpp:23403

vk::DescriptorAddressInfoEXT
Definition: vulkan_structs.hpp:23515

vk::DescriptorBufferBindingInfoEXT
Definition: vulkan_structs.hpp:23634

vk::DescriptorBufferBindingPushDescriptorBufferHandleEXT
Definition: vulkan_structs.hpp:23743

vk::DescriptorGetInfoEXT
Definition: vulkan_structs.hpp:24155

vk::DescriptorPoolInlineUniformBlockCreateInfo
Definition: vulkan_structs.hpp:24480

vk::DescriptorSetBindingReferenceVALVE
Definition: vulkan_structs.hpp:24719

vk::DescriptorSetLayoutBindingFlagsCreateInfo
Definition: vulkan_structs.hpp:24969

vk::DescriptorSetLayoutHostMappingInfoVALVE
Definition: vulkan_structs.hpp:25237

vk::DescriptorSetLayoutSupport
Definition: vulkan_structs.hpp:25342

vk::DescriptorSetVariableDescriptorCountAllocateInfo
Definition: vulkan_structs.hpp:25426

vk::DescriptorSetVariableDescriptorCountLayoutSupport
Definition: vulkan_structs.hpp:25554

vk::DescriptorUpdateTemplateCreateInfo
Definition: vulkan_structs.hpp:25767

vk::DescriptorUpdateTemplateEntry
Definition: vulkan_structs.hpp:25641

vk::DeviceAddressBindingCallbackDataEXT
Definition: vulkan_structs.hpp:25982

vk::DeviceBufferMemoryRequirements
Definition: vulkan_structs.hpp:26114

vk::DeviceDeviceMemoryReportCreateInfoEXT
Definition: vulkan_structs.hpp:27341

vk::DeviceDiagnosticsConfigCreateInfoNV
Definition: vulkan_structs.hpp:27458

vk::DeviceEventInfoEXT
Definition: vulkan_structs.hpp:27555

vk::DeviceFaultAddressInfoEXT
Definition: vulkan_structs.hpp:27649

vk::DeviceFaultCountsEXT
Definition: vulkan_structs.hpp:27746

vk::DeviceFaultInfoEXT
Definition: vulkan_structs.hpp:27958

vk::DeviceFaultVendorBinaryHeaderVersionOneEXT
Definition: vulkan_structs.hpp:28085

vk::DeviceFaultVendorInfoEXT
Definition: vulkan_structs.hpp:27862

vk::DeviceGroupBindSparseInfo
Definition: vulkan_structs.hpp:28279

vk::DeviceGroupCommandBufferBeginInfo
Definition: vulkan_structs.hpp:28387

vk::DeviceGroupDeviceCreateInfo
Definition: vulkan_structs.hpp:28485

vk::DeviceGroupPresentCapabilitiesKHR
Definition: vulkan_structs.hpp:28613

vk::DeviceGroupPresentInfoKHR
Definition: vulkan_structs.hpp:28702

vk::DeviceGroupRenderPassBeginInfo
Definition: vulkan_structs.hpp:28841

vk::DeviceGroupSubmitInfo
Definition: vulkan_structs.hpp:28983

vk::DeviceGroupSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:29190

vk::DeviceImageMemoryRequirements
Definition: vulkan_structs.hpp:29562

vk::DeviceImageSubresourceInfoKHR
Definition: vulkan_structs.hpp:29772

vk::DeviceMemoryOpaqueCaptureAddressInfo
Definition: vulkan_structs.hpp:29882

vk::DeviceMemoryOverallocationCreateInfoAMD
Definition: vulkan_structs.hpp:29981

vk::DeviceMemoryReportCallbackDataEXT
Definition: vulkan_structs.hpp:30080

vk::DevicePrivateDataCreateInfo
Definition: vulkan_structs.hpp:30236

vk::DeviceQueueGlobalPriorityCreateInfoKHR
Definition: vulkan_structs.hpp:30334

vk::DeviceQueueInfo2
Definition: vulkan_structs.hpp:30435

vk::DeviceQueueShaderCoreControlCreateInfoARM
Definition: vulkan_structs.hpp:30552

vk::DirectDriverLoadingInfoLUNARG
Definition: vulkan_structs.hpp:30648

vk::DirectDriverLoadingListLUNARG
Definition: vulkan_structs.hpp:30754

vk::DisplayEventInfoEXT
Definition: vulkan_structs.hpp:31274

vk::DisplayModeCreateInfoKHR
Definition: vulkan_structs.hpp:31457

vk::DisplayModeParametersKHR
Definition: vulkan_structs.hpp:31371

vk::DisplayModeProperties2KHR
Definition: vulkan_structs.hpp:31639

vk::DisplayModePropertiesKHR
Definition: vulkan_structs.hpp:31566

vk::DisplayNativeHdrSurfaceCapabilitiesAMD
Definition: vulkan_structs.hpp:31722

vk::DisplayPlaneCapabilities2KHR
Definition: vulkan_structs.hpp:31909

vk::DisplayPlaneCapabilitiesKHR
Definition: vulkan_structs.hpp:31805

vk::DisplayPlaneInfo2KHR
Definition: vulkan_structs.hpp:31992

vk::DisplayPlaneProperties2KHR
Definition: vulkan_structs.hpp:32170

vk::DisplayPlanePropertiesKHR
Definition: vulkan_structs.hpp:32097

vk::DisplayPowerInfoEXT
Definition: vulkan_structs.hpp:32253

vk::DisplayPresentInfoKHR
Definition: vulkan_structs.hpp:32349

vk::DisplayProperties2KHR
Definition: vulkan_structs.hpp:32580

vk::DisplayPropertiesKHR
Definition: vulkan_structs.hpp:32468

vk::DisplaySurfaceCreateInfoKHR
Definition: vulkan_structs.hpp:32663

vk::DrawMeshTasksIndirectCommandEXT
Definition: vulkan_structs.hpp:33055

vk::DrawMeshTasksIndirectCommandNV
Definition: vulkan_structs.hpp:33150

vk::DrmFormatModifierProperties2EXT
Definition: vulkan_structs.hpp:33236

vk::DrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:33313

vk::DrmFormatModifierPropertiesList2EXT
Definition: vulkan_structs.hpp:33390

vk::DrmFormatModifierPropertiesListEXT
Definition: vulkan_structs.hpp:33488

vk::ExportFenceCreateInfo
Definition: vulkan_structs.hpp:34098

vk::ExportMemoryAllocateInfoNV
Definition: vulkan_structs.hpp:34413

vk::ExportMemoryAllocateInfo
Definition: vulkan_structs.hpp:34314

vk::ExportSemaphoreCreateInfo
Definition: vulkan_structs.hpp:35608

vk::ExternalBufferProperties
Definition: vulkan_structs.hpp:35978

vk::ExternalFenceProperties
Definition: vulkan_structs.hpp:36063

vk::ExternalImageFormatPropertiesNV
Definition: vulkan_structs.hpp:36524

vk::ExternalImageFormatProperties
Definition: vulkan_structs.hpp:36352

vk::ExternalMemoryAcquireUnmodifiedEXT
Definition: vulkan_structs.hpp:36608

vk::ExternalMemoryBufferCreateInfo
Definition: vulkan_structs.hpp:36706

vk::ExternalMemoryImageCreateInfoNV
Definition: vulkan_structs.hpp:36906

vk::ExternalMemoryImageCreateInfo
Definition: vulkan_structs.hpp:36806

vk::ExternalMemoryProperties
Definition: vulkan_structs.hpp:35897

vk::ExternalSemaphoreProperties
Definition: vulkan_structs.hpp:37004

vk::FenceGetFdInfoKHR
Definition: vulkan_structs.hpp:37193

vk::FilterCubicImageViewImageFormatPropertiesEXT
Definition: vulkan_structs.hpp:37412

vk::FormatProperties2
Definition: vulkan_structs.hpp:37574

vk::FormatProperties3
Definition: vulkan_structs.hpp:37655

vk::FragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:37748

vk::FrameBoundaryEXT
Definition: vulkan_structs.hpp:37860

vk::FramebufferAttachmentImageInfo
Definition: vulkan_structs.hpp:38089

vk::FramebufferAttachmentsCreateInfo
Definition: vulkan_structs.hpp:38281

vk::FramebufferMixedSamplesCombinationNV
Definition: vulkan_structs.hpp:38607

vk::GeneratedCommandsInfoNV
Definition: vulkan_structs.hpp:38793

vk::GeneratedCommandsMemoryRequirementsInfoNV
Definition: vulkan_structs.hpp:39075

vk::GeometryAABBNV
Definition: vulkan_structs.hpp:1657

vk::GeometryDataNV
Definition: vulkan_structs.hpp:1784

vk::GeometryNV
Definition: vulkan_structs.hpp:1868

vk::GeometryTrianglesNV
Definition: vulkan_structs.hpp:1444

vk::GetLatencyMarkerInfoNV
Definition: vulkan_structs.hpp:39457

vk::GraphicsPipelineLibraryCreateInfoEXT
Definition: vulkan_structs.hpp:41915

vk::GraphicsPipelineShaderGroupsCreateInfoNV
Definition: vulkan_structs.hpp:42169

vk::GraphicsShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:42012

vk::HdrMetadataEXT
Definition: vulkan_structs.hpp:42417

vk::HeadlessSurfaceCreateInfoEXT
Definition: vulkan_structs.hpp:42595

vk::HostImageCopyDevicePerformanceQueryEXT
Definition: vulkan_structs.hpp:42692

vk::HostImageLayoutTransitionInfoEXT
Definition: vulkan_structs.hpp:42779

vk::ImageBlit2
Definition: vulkan_structs.hpp:10414

vk::ImageCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:43124

vk::ImageCompressionControlEXT
Definition: vulkan_structs.hpp:43220

vk::ImageCompressionPropertiesEXT
Definition: vulkan_structs.hpp:43363

vk::ImageCopy2
Definition: vulkan_structs.hpp:17733

vk::ImageDrmFormatModifierExplicitCreateInfoEXT
Definition: vulkan_structs.hpp:44029

vk::ImageDrmFormatModifierListCreateInfoEXT
Definition: vulkan_structs.hpp:44174

vk::ImageDrmFormatModifierPropertiesEXT
Definition: vulkan_structs.hpp:44299

vk::ImageFormatListCreateInfo
Definition: vulkan_structs.hpp:44381

vk::ImageFormatProperties2
Definition: vulkan_structs.hpp:44507

vk::ImageMemoryBarrier2
Definition: vulkan_structs.hpp:22866

vk::ImageMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:44761

vk::ImagePlaneMemoryRequirementsInfo
Definition: vulkan_structs.hpp:44979

vk::ImageResolve2
Definition: vulkan_structs.hpp:45195

vk::ImageSparseMemoryRequirementsInfo2
Definition: vulkan_structs.hpp:45334

vk::ImageStencilUsageCreateInfo
Definition: vulkan_structs.hpp:45432

vk::ImageSubresource2KHR
Definition: vulkan_structs.hpp:29674

vk::ImageSwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:45531

vk::ImageToMemoryCopyEXT
Definition: vulkan_structs.hpp:18407

vk::ImageViewASTCDecodeModeEXT
Definition: vulkan_structs.hpp:45627

vk::ImageViewAddressPropertiesNVX
Definition: vulkan_structs.hpp:45724

vk::ImageViewCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:45811

vk::ImageViewHandleInfoNVX
Definition: vulkan_structs.hpp:46058

vk::ImageViewMinLodCreateInfoEXT
Definition: vulkan_structs.hpp:46178

vk::ImageViewSampleWeightCreateInfoQCOM
Definition: vulkan_structs.hpp:46274

vk::ImageViewSlicedCreateInfoEXT
Definition: vulkan_structs.hpp:46394

vk::ImageViewUsageCreateInfo
Definition: vulkan_structs.hpp:46499

vk::ImportFenceFdInfoKHR
Definition: vulkan_structs.hpp:46695

vk::ImportMemoryFdInfoKHR
Definition: vulkan_structs.hpp:47078

vk::ImportMemoryHostPointerInfoEXT
Definition: vulkan_structs.hpp:47185

vk::ImportSemaphoreFdInfoKHR
Definition: vulkan_structs.hpp:48148

vk::IndirectCommandsLayoutCreateInfoNV
Definition: vulkan_structs.hpp:48873

vk::IndirectCommandsLayoutTokenNV
Definition: vulkan_structs.hpp:48570

vk::IndirectCommandsStreamNV
Definition: vulkan_structs.hpp:38706

vk::InitializePerformanceApiInfoINTEL
Definition: vulkan_structs.hpp:49064

vk::InputAttachmentAspectReference
Definition: vulkan_structs.hpp:49160

vk::LatencySleepInfoNV
Definition: vulkan_structs.hpp:49475

vk::LatencySleepModeInfoNV
Definition: vulkan_structs.hpp:49577

vk::LatencySubmissionPresentIdNV
Definition: vulkan_structs.hpp:49697

vk::LatencySurfaceCapabilitiesNV
Definition: vulkan_structs.hpp:49793

vk::LatencyTimingsFrameReportNV
Definition: vulkan_structs.hpp:39208

vk::LayerSettingEXT
Definition: vulkan_structs.hpp:49997

vk::LayerSettingsCreateInfoEXT
Definition: vulkan_structs.hpp:50147

vk::MemoryAllocateFlagsInfo
Definition: vulkan_structs.hpp:50496

vk::MemoryBarrier2
Definition: vulkan_structs.hpp:22622

vk::MemoryDedicatedAllocateInfo
Definition: vulkan_structs.hpp:50813

vk::MemoryDedicatedRequirements
Definition: vulkan_structs.hpp:50921

vk::MemoryFdPropertiesKHR
Definition: vulkan_structs.hpp:51010

vk::MemoryGetFdInfoKHR
Definition: vulkan_structs.hpp:51191

vk::MemoryGetRemoteAddressInfoNV
Definition: vulkan_structs.hpp:51298

vk::MemoryHostPointerPropertiesEXT
Definition: vulkan_structs.hpp:51704

vk::MemoryMapInfoKHR
Definition: vulkan_structs.hpp:51786

vk::MemoryOpaqueCaptureAddressAllocateInfo
Definition: vulkan_structs.hpp:51913

vk::MemoryPriorityAllocateInfoEXT
Definition: vulkan_structs.hpp:52011

vk::MemoryRequirements2
Definition: vulkan_structs.hpp:52180

vk::MemoryToImageCopyEXT
Definition: vulkan_structs.hpp:19055

vk::MemoryUnmapInfoKHR
Definition: vulkan_structs.hpp:52332

vk::MicromapBuildInfoEXT
Definition: vulkan_structs.hpp:52717

vk::MicromapBuildSizesInfoEXT
Definition: vulkan_structs.hpp:52956

vk::MicromapCreateInfoEXT
Definition: vulkan_structs.hpp:53076

vk::MicromapTriangleEXT
Definition: vulkan_structs.hpp:53226

vk::MicromapUsageEXT
Definition: vulkan_structs.hpp:3534

vk::MicromapVersionInfoEXT
Definition: vulkan_structs.hpp:53319

vk::MultiDrawIndexedInfoEXT
Definition: vulkan_structs.hpp:53415

vk::MultiDrawInfoEXT
Definition: vulkan_structs.hpp:53509

vk::MultisamplePropertiesEXT
Definition: vulkan_structs.hpp:53592

vk::MultisampledRenderToSingleSampledInfoEXT
Definition: vulkan_structs.hpp:53674

vk::MultiviewPerViewAttributesInfoNVX
Definition: vulkan_structs.hpp:53787

vk::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM
Definition: vulkan_structs.hpp:53895

vk::MutableDescriptorTypeCreateInfoEXT
Definition: vulkan_structs.hpp:54131

vk::MutableDescriptorTypeListEXT
Definition: vulkan_structs.hpp:54024

vk::OpaqueCaptureDescriptorDataCreateInfoEXT
Definition: vulkan_structs.hpp:54267

vk::OpticalFlowExecuteInfoNV
Definition: vulkan_structs.hpp:54365

vk::OpticalFlowImageFormatInfoNV
Definition: vulkan_structs.hpp:54503

vk::OpticalFlowImageFormatPropertiesNV
Definition: vulkan_structs.hpp:54600

vk::OpticalFlowSessionCreateInfoNV
Definition: vulkan_structs.hpp:54683

vk::OpticalFlowSessionCreatePrivateDataInfoNV
Definition: vulkan_structs.hpp:54868

vk::OutOfBandQueueTypeInfoNV
Definition: vulkan_structs.hpp:54983

vk::PastPresentationTimingGOOGLE
Definition: vulkan_structs.hpp:55080

vk::PerformanceConfigurationAcquireInfoINTEL
Definition: vulkan_structs.hpp:55163

vk::PerformanceCounterDescriptionKHR
Definition: vulkan_structs.hpp:55264

vk::PerformanceCounterKHR
Definition: vulkan_structs.hpp:55362

vk::PerformanceMarkerInfoINTEL
Definition: vulkan_structs.hpp:55535

vk::PerformanceOverrideInfoINTEL
Definition: vulkan_structs.hpp:55631

vk::PerformanceQuerySubmitInfoKHR
Definition: vulkan_structs.hpp:55751

vk::PerformanceStreamMarkerInfoINTEL
Definition: vulkan_structs.hpp:55847

vk::PerformanceValueINTEL
Definition: vulkan_structs.hpp:56014

vk::PhysicalDevice16BitStorageFeatures
Definition: vulkan_structs.hpp:56084

vk::PhysicalDevice4444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:56221

vk::PhysicalDevice8BitStorageFeatures
Definition: vulkan_structs.hpp:56327

vk::PhysicalDeviceASTCDecodeFeaturesEXT
Definition: vulkan_structs.hpp:56452

vk::PhysicalDeviceAccelerationStructureFeaturesKHR
Definition: vulkan_structs.hpp:56550

vk::PhysicalDeviceAccelerationStructurePropertiesKHR
Definition: vulkan_structs.hpp:56706

vk::PhysicalDeviceAddressBindingReportFeaturesEXT
Definition: vulkan_structs.hpp:56835

vk::PhysicalDeviceAmigoProfilingFeaturesSEC
Definition: vulkan_structs.hpp:56934

vk::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:57031

vk::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
Definition: vulkan_structs.hpp:57133

vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
Definition: vulkan_structs.hpp:57233

vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT
Definition: vulkan_structs.hpp:57332

vk::PhysicalDeviceBorderColorSwizzleFeaturesEXT
Definition: vulkan_structs.hpp:57450

vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT
Definition: vulkan_structs.hpp:57685

vk::PhysicalDeviceBufferDeviceAddressFeatures
Definition: vulkan_structs.hpp:57559

vk::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI
Definition: vulkan_structs.hpp:57811

vk::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI
Definition: vulkan_structs.hpp:57921

vk::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI
Definition: vulkan_structs.hpp:58022

vk::PhysicalDeviceCoherentMemoryFeaturesAMD
Definition: vulkan_structs.hpp:58122

vk::PhysicalDeviceColorWriteEnableFeaturesEXT
Definition: vulkan_structs.hpp:58220

vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV
Definition: vulkan_structs.hpp:58318

vk::PhysicalDeviceConditionalRenderingFeaturesEXT
Definition: vulkan_structs.hpp:58428

vk::PhysicalDeviceConservativeRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:58538

vk::PhysicalDeviceCooperativeMatrixFeaturesKHR
Definition: vulkan_structs.hpp:58674

vk::PhysicalDeviceCooperativeMatrixFeaturesNV
Definition: vulkan_structs.hpp:58783

vk::PhysicalDeviceCooperativeMatrixPropertiesKHR
Definition: vulkan_structs.hpp:58892

vk::PhysicalDeviceCooperativeMatrixPropertiesNV
Definition: vulkan_structs.hpp:58975

vk::PhysicalDeviceCopyMemoryIndirectFeaturesNV
Definition: vulkan_structs.hpp:59058

vk::PhysicalDeviceCopyMemoryIndirectPropertiesNV
Definition: vulkan_structs.hpp:59155

vk::PhysicalDeviceCornerSampledImageFeaturesNV
Definition: vulkan_structs.hpp:59238

vk::PhysicalDeviceCoverageReductionModeFeaturesNV
Definition: vulkan_structs.hpp:59336

vk::PhysicalDeviceCubicClampFeaturesQCOM
Definition: vulkan_structs.hpp:59435

vk::PhysicalDeviceCubicWeightsFeaturesQCOM
Definition: vulkan_structs.hpp:59531

vk::PhysicalDeviceCustomBorderColorFeaturesEXT
Definition: vulkan_structs.hpp:59818

vk::PhysicalDeviceCustomBorderColorPropertiesEXT
Definition: vulkan_structs.hpp:59927

vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
Definition: vulkan_structs.hpp:60010

vk::PhysicalDeviceDepthBiasControlFeaturesEXT
Definition: vulkan_structs.hpp:60111

vk::PhysicalDeviceDepthClampZeroOneFeaturesEXT
Definition: vulkan_structs.hpp:60245

vk::PhysicalDeviceDepthClipControlFeaturesEXT
Definition: vulkan_structs.hpp:60343

vk::PhysicalDeviceDepthClipEnableFeaturesEXT
Definition: vulkan_structs.hpp:60441

vk::PhysicalDeviceDepthStencilResolveProperties
Definition: vulkan_structs.hpp:60538

vk::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:60639

vk::PhysicalDeviceDescriptorBufferFeaturesEXT
Definition: vulkan_structs.hpp:60725

vk::PhysicalDeviceDescriptorBufferPropertiesEXT
Definition: vulkan_structs.hpp:60861

vk::PhysicalDeviceDescriptorIndexingFeatures
Definition: vulkan_structs.hpp:61138

vk::PhysicalDeviceDescriptorIndexingProperties
Definition: vulkan_structs.hpp:61490

vk::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV
Definition: vulkan_structs.hpp:61710

vk::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
Definition: vulkan_structs.hpp:61810

vk::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV
Definition: vulkan_structs.hpp:61910

vk::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
Definition: vulkan_structs.hpp:62037

vk::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
Definition: vulkan_structs.hpp:62136

vk::PhysicalDeviceDeviceMemoryReportFeaturesEXT
Definition: vulkan_structs.hpp:62272

vk::PhysicalDeviceDiagnosticsConfigFeaturesNV
Definition: vulkan_structs.hpp:62370

vk::PhysicalDeviceDiscardRectanglePropertiesEXT
Definition: vulkan_structs.hpp:62468

vk::PhysicalDeviceDriverProperties
Definition: vulkan_structs.hpp:62736

vk::PhysicalDeviceDrmPropertiesEXT
Definition: vulkan_structs.hpp:62836

vk::PhysicalDeviceDynamicRenderingFeatures
Definition: vulkan_structs.hpp:62943

vk::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT
Definition: vulkan_structs.hpp:63042

vk::PhysicalDeviceExclusiveScissorFeaturesNV
Definition: vulkan_structs.hpp:63144

vk::PhysicalDeviceExtendedDynamicState2FeaturesEXT
Definition: vulkan_structs.hpp:63241

vk::PhysicalDeviceExtendedDynamicState3FeaturesEXT
Definition: vulkan_structs.hpp:63366

vk::PhysicalDeviceExtendedDynamicState3PropertiesEXT
Definition: vulkan_structs.hpp:63861

vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:63960

vk::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV
Definition: vulkan_structs.hpp:64059

vk::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV
Definition: vulkan_structs.hpp:64159

vk::PhysicalDeviceExternalBufferInfo
Definition: vulkan_structs.hpp:64255

vk::PhysicalDeviceExternalFenceInfo
Definition: vulkan_structs.hpp:64378

vk::PhysicalDeviceExternalImageFormatInfo
Definition: vulkan_structs.hpp:64682

vk::PhysicalDeviceExternalMemoryHostPropertiesEXT
Definition: vulkan_structs.hpp:64783

vk::PhysicalDeviceExternalMemoryRDMAFeaturesNV
Definition: vulkan_structs.hpp:64867

vk::PhysicalDeviceExternalSemaphoreInfo
Definition: vulkan_structs.hpp:65067

vk::PhysicalDeviceFaultFeaturesEXT
Definition: vulkan_structs.hpp:65168

vk::PhysicalDeviceFeatures2
Definition: vulkan_structs.hpp:65276

vk::PhysicalDeviceFloatControlsProperties
Definition: vulkan_structs.hpp:65374

vk::PhysicalDeviceFragmentDensityMap2FeaturesEXT
Definition: vulkan_structs.hpp:65555

vk::PhysicalDeviceFragmentDensityMap2PropertiesEXT
Definition: vulkan_structs.hpp:65653

vk::PhysicalDeviceFragmentDensityMapFeaturesEXT
Definition: vulkan_structs.hpp:65753

vk::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
Definition: vulkan_structs.hpp:65877

vk::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
Definition: vulkan_structs.hpp:65977

vk::PhysicalDeviceFragmentDensityMapPropertiesEXT
Definition: vulkan_structs.hpp:66062

vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR
Definition: vulkan_structs.hpp:66157

vk::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR
Definition: vulkan_structs.hpp:66259

vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT
Definition: vulkan_structs.hpp:66346

vk::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
Definition: vulkan_structs.hpp:66471

vk::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
Definition: vulkan_structs.hpp:66596

vk::PhysicalDeviceFragmentShadingRateFeaturesKHR
Definition: vulkan_structs.hpp:66697

vk::PhysicalDeviceFragmentShadingRateKHR
Definition: vulkan_structs.hpp:66820

vk::PhysicalDeviceFragmentShadingRatePropertiesKHR
Definition: vulkan_structs.hpp:66907

vk::PhysicalDeviceFrameBoundaryFeaturesEXT
Definition: vulkan_structs.hpp:67092

vk::PhysicalDeviceGlobalPriorityQueryFeaturesKHR
Definition: vulkan_structs.hpp:67188

vk::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
Definition: vulkan_structs.hpp:67288

vk::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
Definition: vulkan_structs.hpp:67387

vk::PhysicalDeviceGroupProperties
Definition: vulkan_structs.hpp:67499

vk::PhysicalDeviceHostImageCopyFeaturesEXT
Definition: vulkan_structs.hpp:67596

vk::PhysicalDeviceHostImageCopyPropertiesEXT
Definition: vulkan_structs.hpp:67692

vk::PhysicalDeviceHostQueryResetFeatures
Definition: vulkan_structs.hpp:67885

vk::PhysicalDeviceIDProperties
Definition: vulkan_structs.hpp:67983

vk::PhysicalDeviceImage2DViewOf3DFeaturesEXT
Definition: vulkan_structs.hpp:68087

vk::PhysicalDeviceImageCompressionControlFeaturesEXT
Definition: vulkan_structs.hpp:68194

vk::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
Definition: vulkan_structs.hpp:68293

vk::PhysicalDeviceImageDrmFormatModifierInfoEXT
Definition: vulkan_structs.hpp:68395

vk::PhysicalDeviceImageFormatInfo2
Definition: vulkan_structs.hpp:68550

vk::PhysicalDeviceImageProcessing2FeaturesQCOM
Definition: vulkan_structs.hpp:68692

vk::PhysicalDeviceImageProcessing2PropertiesQCOM
Definition: vulkan_structs.hpp:68790

vk::PhysicalDeviceImageProcessingFeaturesQCOM
Definition: vulkan_structs.hpp:68873

vk::PhysicalDeviceImageProcessingPropertiesQCOM
Definition: vulkan_structs.hpp:68996

vk::PhysicalDeviceImageRobustnessFeatures
Definition: vulkan_structs.hpp:69095

vk::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT
Definition: vulkan_structs.hpp:69194

vk::PhysicalDeviceImageViewImageFormatInfoEXT
Definition: vulkan_structs.hpp:69292

vk::PhysicalDeviceImageViewMinLodFeaturesEXT
Definition: vulkan_structs.hpp:69391

vk::PhysicalDeviceImagelessFramebufferFeatures
Definition: vulkan_structs.hpp:69487

vk::PhysicalDeviceIndexTypeUint8FeaturesEXT
Definition: vulkan_structs.hpp:69587

vk::PhysicalDeviceInheritedViewportScissorFeaturesNV
Definition: vulkan_structs.hpp:69684

vk::PhysicalDeviceInlineUniformBlockFeatures
Definition: vulkan_structs.hpp:69783

vk::PhysicalDeviceInlineUniformBlockProperties
Definition: vulkan_structs.hpp:69894

vk::PhysicalDeviceInvocationMaskFeaturesHUAWEI
Definition: vulkan_structs.hpp:70007

vk::PhysicalDeviceLayeredDriverPropertiesMSFT
Definition: vulkan_structs.hpp:70104

vk::PhysicalDeviceLegacyDitheringFeaturesEXT
Definition: vulkan_structs.hpp:70188

vk::PhysicalDeviceLineRasterizationFeaturesEXT
Definition: vulkan_structs.hpp:70941

vk::PhysicalDeviceLineRasterizationPropertiesEXT
Definition: vulkan_structs.hpp:71096

vk::PhysicalDeviceLinearColorAttachmentFeaturesNV
Definition: vulkan_structs.hpp:71178

vk::PhysicalDeviceMaintenance3Properties
Definition: vulkan_structs.hpp:71277

vk::PhysicalDeviceMaintenance4Features
Definition: vulkan_structs.hpp:71366

vk::PhysicalDeviceMaintenance4Properties
Definition: vulkan_structs.hpp:71464

vk::PhysicalDeviceMaintenance5FeaturesKHR
Definition: vulkan_structs.hpp:71549

vk::PhysicalDeviceMaintenance5PropertiesKHR
Definition: vulkan_structs.hpp:71645

vk::PhysicalDeviceMaintenance6FeaturesKHR
Definition: vulkan_structs.hpp:71762

vk::PhysicalDeviceMaintenance6PropertiesKHR
Definition: vulkan_structs.hpp:71858

vk::PhysicalDeviceMemoryBudgetPropertiesEXT
Definition: vulkan_structs.hpp:71953

vk::PhysicalDeviceMemoryDecompressionFeaturesNV
Definition: vulkan_structs.hpp:72042

vk::PhysicalDeviceMemoryDecompressionPropertiesNV
Definition: vulkan_structs.hpp:72140

vk::PhysicalDeviceMemoryPriorityFeaturesEXT
Definition: vulkan_structs.hpp:72228

vk::PhysicalDeviceMemoryProperties2
Definition: vulkan_structs.hpp:72409

vk::PhysicalDeviceMeshShaderFeaturesEXT
Definition: vulkan_structs.hpp:72494

vk::PhysicalDeviceMeshShaderFeaturesNV
Definition: vulkan_structs.hpp:72637

vk::PhysicalDeviceMeshShaderPropertiesEXT
Definition: vulkan_structs.hpp:72743

vk::PhysicalDeviceMeshShaderPropertiesNV
Definition: vulkan_structs.hpp:72981

vk::PhysicalDeviceMultiDrawFeaturesEXT
Definition: vulkan_structs.hpp:73135

vk::PhysicalDeviceMultiDrawPropertiesEXT
Definition: vulkan_structs.hpp:73231

vk::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
Definition: vulkan_structs.hpp:73313

vk::PhysicalDeviceMultiviewFeatures
Definition: vulkan_structs.hpp:73415

vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
Definition: vulkan_structs.hpp:73539

vk::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM
Definition: vulkan_structs.hpp:73624

vk::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
Definition: vulkan_structs.hpp:73724

vk::PhysicalDeviceMultiviewProperties
Definition: vulkan_structs.hpp:73824

vk::PhysicalDeviceMutableDescriptorTypeFeaturesEXT
Definition: vulkan_structs.hpp:73913

vk::PhysicalDeviceNestedCommandBufferFeaturesEXT
Definition: vulkan_structs.hpp:74014

vk::PhysicalDeviceNestedCommandBufferPropertiesEXT
Definition: vulkan_structs.hpp:74138

vk::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT
Definition: vulkan_structs.hpp:74237

vk::PhysicalDeviceOpacityMicromapFeaturesEXT
Definition: vulkan_structs.hpp:74335

vk::PhysicalDeviceOpacityMicromapPropertiesEXT
Definition: vulkan_structs.hpp:74457

vk::PhysicalDeviceOpticalFlowFeaturesNV
Definition: vulkan_structs.hpp:74544

vk::PhysicalDeviceOpticalFlowPropertiesNV
Definition: vulkan_structs.hpp:74640

vk::PhysicalDevicePCIBusInfoPropertiesEXT
Definition: vulkan_structs.hpp:74781

vk::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
Definition: vulkan_structs.hpp:74871

vk::PhysicalDevicePerStageDescriptorSetFeaturesNV
Definition: vulkan_structs.hpp:74971

vk::PhysicalDevicePerformanceQueryFeaturesKHR
Definition: vulkan_structs.hpp:75081

vk::PhysicalDevicePerformanceQueryPropertiesKHR
Definition: vulkan_structs.hpp:75190

vk::PhysicalDevicePipelineCreationCacheControlFeatures
Definition: vulkan_structs.hpp:75273

vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
Definition: vulkan_structs.hpp:75375

vk::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT
Definition: vulkan_structs.hpp:75475

vk::PhysicalDevicePipelinePropertiesFeaturesEXT
Definition: vulkan_structs.hpp:75575

vk::PhysicalDevicePipelineProtectedAccessFeaturesEXT
Definition: vulkan_structs.hpp:75673

vk::PhysicalDevicePipelineRobustnessFeaturesEXT
Definition: vulkan_structs.hpp:75772

vk::PhysicalDevicePipelineRobustnessPropertiesEXT
Definition: vulkan_structs.hpp:75870

vk::PhysicalDevicePointClippingProperties
Definition: vulkan_structs.hpp:75978

vk::PhysicalDevicePresentBarrierFeaturesNV
Definition: vulkan_structs.hpp:76441

vk::PhysicalDevicePresentIdFeaturesKHR
Definition: vulkan_structs.hpp:76538

vk::PhysicalDevicePresentWaitFeaturesKHR
Definition: vulkan_structs.hpp:76634

vk::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
Definition: vulkan_structs.hpp:76730

vk::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT
Definition: vulkan_structs.hpp:76841

vk::PhysicalDevicePrivateDataFeatures
Definition: vulkan_structs.hpp:76967

vk::PhysicalDeviceProperties2
Definition: vulkan_structs.hpp:77262

vk::PhysicalDeviceProtectedMemoryFeatures
Definition: vulkan_structs.hpp:77347

vk::PhysicalDeviceProtectedMemoryProperties
Definition: vulkan_structs.hpp:77444

vk::PhysicalDeviceProvokingVertexFeaturesEXT
Definition: vulkan_structs.hpp:77527

vk::PhysicalDeviceProvokingVertexPropertiesEXT
Definition: vulkan_structs.hpp:77636

vk::PhysicalDevicePushDescriptorPropertiesKHR
Definition: vulkan_structs.hpp:77723

vk::PhysicalDeviceRGBA10X6FormatsFeaturesEXT
Definition: vulkan_structs.hpp:77805

vk::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
Definition: vulkan_structs.hpp:77903

vk::PhysicalDeviceRayQueryFeaturesKHR
Definition: vulkan_structs.hpp:78035

vk::PhysicalDeviceRayTracingInvocationReorderFeaturesNV
Definition: vulkan_structs.hpp:78131

vk::PhysicalDeviceRayTracingInvocationReorderPropertiesNV
Definition: vulkan_structs.hpp:78231

vk::PhysicalDeviceRayTracingMaintenance1FeaturesKHR
Definition: vulkan_structs.hpp:78319

vk::PhysicalDeviceRayTracingMotionBlurFeaturesNV
Definition: vulkan_structs.hpp:78429

vk::PhysicalDeviceRayTracingPipelineFeaturesKHR
Definition: vulkan_structs.hpp:78538

vk::PhysicalDeviceRayTracingPipelinePropertiesKHR
Definition: vulkan_structs.hpp:78692

vk::PhysicalDeviceRayTracingPositionFetchFeaturesKHR
Definition: vulkan_structs.hpp:78819

vk::PhysicalDeviceRayTracingPropertiesNV
Definition: vulkan_structs.hpp:78918

vk::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG
Definition: vulkan_structs.hpp:79044

vk::PhysicalDeviceRenderPassStripedFeaturesARM
Definition: vulkan_structs.hpp:79144

vk::PhysicalDeviceRenderPassStripedPropertiesARM
Definition: vulkan_structs.hpp:79242

vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
Definition: vulkan_structs.hpp:79329

vk::PhysicalDeviceRobustness2FeaturesEXT
Definition: vulkan_structs.hpp:79429

vk::PhysicalDeviceRobustness2PropertiesEXT
Definition: vulkan_structs.hpp:79550

vk::PhysicalDeviceSampleLocationsPropertiesEXT
Definition: vulkan_structs.hpp:79637

vk::PhysicalDeviceSamplerFilterMinmaxProperties
Definition: vulkan_structs.hpp:79746

vk::PhysicalDeviceSamplerYcbcrConversionFeatures
Definition: vulkan_structs.hpp:79835

vk::PhysicalDeviceScalarBlockLayoutFeatures
Definition: vulkan_structs.hpp:79935

vk::PhysicalDeviceSchedulingControlsFeaturesARM
Definition: vulkan_structs.hpp:80035

vk::PhysicalDeviceSchedulingControlsPropertiesARM
Definition: vulkan_structs.hpp:80133

vk::PhysicalDeviceSeparateDepthStencilLayoutsFeatures
Definition: vulkan_structs.hpp:80233

vk::PhysicalDeviceShaderAtomicFloat2FeaturesEXT
Definition: vulkan_structs.hpp:80335

vk::PhysicalDeviceShaderAtomicFloatFeaturesEXT
Definition: vulkan_structs.hpp:80579

vk::PhysicalDeviceShaderAtomicInt64Features
Definition: vulkan_structs.hpp:80819

vk::PhysicalDeviceShaderClockFeaturesKHR
Definition: vulkan_structs.hpp:80930

vk::PhysicalDeviceShaderCoreBuiltinsFeaturesARM
Definition: vulkan_structs.hpp:81038

vk::PhysicalDeviceShaderCoreBuiltinsPropertiesARM
Definition: vulkan_structs.hpp:81136

vk::PhysicalDeviceShaderCoreProperties2AMD
Definition: vulkan_structs.hpp:81227

vk::PhysicalDeviceShaderCorePropertiesAMD
Definition: vulkan_structs.hpp:81314

vk::PhysicalDeviceShaderCorePropertiesARM
Definition: vulkan_structs.hpp:81472

vk::PhysicalDeviceShaderDemoteToHelperInvocationFeatures
Definition: vulkan_structs.hpp:81561

vk::PhysicalDeviceShaderDrawParametersFeatures
Definition: vulkan_structs.hpp:81663

vk::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
Definition: vulkan_structs.hpp:81763

vk::PhysicalDeviceShaderFloat16Int8Features
Definition: vulkan_structs.hpp:82118

vk::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
Definition: vulkan_structs.hpp:82227

vk::PhysicalDeviceShaderImageFootprintFeaturesNV
Definition: vulkan_structs.hpp:82337

vk::PhysicalDeviceShaderIntegerDotProductFeatures
Definition: vulkan_structs.hpp:82434

vk::PhysicalDeviceShaderIntegerDotProductProperties
Definition: vulkan_structs.hpp:82535

vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
Definition: vulkan_structs.hpp:82808

vk::PhysicalDeviceShaderModuleIdentifierFeaturesEXT
Definition: vulkan_structs.hpp:82908

vk::PhysicalDeviceShaderModuleIdentifierPropertiesEXT
Definition: vulkan_structs.hpp:83007

vk::PhysicalDeviceShaderObjectFeaturesEXT
Definition: vulkan_structs.hpp:83093

vk::PhysicalDeviceShaderObjectPropertiesEXT
Definition: vulkan_structs.hpp:83189

vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV
Definition: vulkan_structs.hpp:83277

vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV
Definition: vulkan_structs.hpp:83374

vk::PhysicalDeviceShaderSubgroupExtendedTypesFeatures
Definition: vulkan_structs.hpp:83459

vk::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
Definition: vulkan_structs.hpp:83561

vk::PhysicalDeviceShaderTerminateInvocationFeatures
Definition: vulkan_structs.hpp:83663

vk::PhysicalDeviceShaderTileImageFeaturesEXT
Definition: vulkan_structs.hpp:83764

vk::PhysicalDeviceShaderTileImagePropertiesEXT
Definition: vulkan_structs.hpp:83888

vk::PhysicalDeviceShadingRateImageFeaturesNV
Definition: vulkan_structs.hpp:83984

vk::PhysicalDeviceShadingRateImagePropertiesNV
Definition: vulkan_structs.hpp:84092

vk::PhysicalDeviceSparseImageFormatInfo2
Definition: vulkan_structs.hpp:84182

vk::PhysicalDeviceSubgroupSizeControlFeatures
Definition: vulkan_structs.hpp:84423

vk::PhysicalDeviceSubgroupSizeControlProperties
Definition: vulkan_structs.hpp:84534

vk::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:84634

vk::PhysicalDeviceSubpassShadingFeaturesHUAWEI
Definition: vulkan_structs.hpp:84733

vk::PhysicalDeviceSubpassShadingPropertiesHUAWEI
Definition: vulkan_structs.hpp:84830

vk::PhysicalDeviceSurfaceInfo2KHR
Definition: vulkan_structs.hpp:84913

vk::PhysicalDeviceSwapchainMaintenance1FeaturesEXT
Definition: vulkan_structs.hpp:85009

vk::PhysicalDeviceSynchronization2Features
Definition: vulkan_structs.hpp:85108

vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT
Definition: vulkan_structs.hpp:85207

vk::PhysicalDeviceTexelBufferAlignmentProperties
Definition: vulkan_structs.hpp:85306

vk::PhysicalDeviceTextureCompressionASTCHDRFeatures
Definition: vulkan_structs.hpp:85413

vk::PhysicalDeviceTilePropertiesFeaturesQCOM
Definition: vulkan_structs.hpp:85514

vk::PhysicalDeviceTimelineSemaphoreFeatures
Definition: vulkan_structs.hpp:85611

vk::PhysicalDeviceTimelineSemaphoreProperties
Definition: vulkan_structs.hpp:85711

vk::PhysicalDeviceToolProperties
Definition: vulkan_structs.hpp:85796

vk::PhysicalDeviceTransformFeedbackFeaturesEXT
Definition: vulkan_structs.hpp:85900

vk::PhysicalDeviceTransformFeedbackPropertiesEXT
Definition: vulkan_structs.hpp:86007

vk::PhysicalDeviceUniformBufferStandardLayoutFeatures
Definition: vulkan_structs.hpp:86147

vk::PhysicalDeviceVariablePointersFeatures
Definition: vulkan_structs.hpp:86249

vk::PhysicalDeviceVertexAttributeDivisorFeaturesKHR
Definition: vulkan_structs.hpp:86361

vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT
Definition: vulkan_structs.hpp:86473

vk::PhysicalDeviceVertexAttributeDivisorPropertiesKHR
Definition: vulkan_structs.hpp:86557

vk::PhysicalDeviceVertexInputDynamicStateFeaturesEXT
Definition: vulkan_structs.hpp:86646

vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR
Definition: vulkan_structs.hpp:86877

vk::PhysicalDeviceVideoFormatInfoKHR
Definition: vulkan_structs.hpp:86984

vk::PhysicalDeviceVideoMaintenance1FeaturesKHR
Definition: vulkan_structs.hpp:87081

vk::PhysicalDeviceVulkan11Features
Definition: vulkan_structs.hpp:87179

vk::PhysicalDeviceVulkan11Properties
Definition: vulkan_structs.hpp:87413

vk::PhysicalDeviceVulkan12Features
Definition: vulkan_structs.hpp:87578

vk::PhysicalDeviceVulkan12Properties
Definition: vulkan_structs.hpp:88253

vk::PhysicalDeviceVulkan13Features
Definition: vulkan_structs.hpp:88636

vk::PhysicalDeviceVulkan13Properties
Definition: vulkan_structs.hpp:88906

vk::PhysicalDeviceVulkanMemoryModelFeatures
Definition: vulkan_structs.hpp:89263

vk::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
Definition: vulkan_structs.hpp:89389

vk::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
Definition: vulkan_structs.hpp:89534

vk::PhysicalDeviceYcbcrDegammaFeaturesQCOM
Definition: vulkan_structs.hpp:89633

vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT
Definition: vulkan_structs.hpp:89729

vk::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
Definition: vulkan_structs.hpp:89827

vk::PipelineColorBlendAdvancedStateCreateInfoEXT
Definition: vulkan_structs.hpp:90190

vk::PipelineColorWriteCreateInfoEXT
Definition: vulkan_structs.hpp:90314

vk::PipelineCompilerControlCreateInfoAMD
Definition: vulkan_structs.hpp:90439

vk::PipelineCoverageModulationStateCreateInfoNV
Definition: vulkan_structs.hpp:90537

vk::PipelineCoverageReductionStateCreateInfoNV
Definition: vulkan_structs.hpp:90710

vk::PipelineCoverageToColorStateCreateInfoNV
Definition: vulkan_structs.hpp:90822

vk::PipelineCreateFlags2CreateInfoKHR
Definition: vulkan_structs.hpp:90944

vk::PipelineCreationFeedbackCreateInfo
Definition: vulkan_structs.hpp:91116

vk::PipelineCreationFeedback
Definition: vulkan_structs.hpp:91041

vk::PipelineDiscardRectangleStateCreateInfoEXT
Definition: vulkan_structs.hpp:91266

vk::PipelineExecutableInfoKHR
Definition: vulkan_structs.hpp:91424

vk::PipelineExecutableInternalRepresentationKHR
Definition: vulkan_structs.hpp:91530

vk::PipelineExecutablePropertiesKHR
Definition: vulkan_structs.hpp:91645

vk::PipelineExecutableStatisticKHR
Definition: vulkan_structs.hpp:91806

vk::PipelineFragmentShadingRateEnumStateCreateInfoNV
Definition: vulkan_structs.hpp:91886

vk::PipelineFragmentShadingRateStateCreateInfoKHR
Definition: vulkan_structs.hpp:92012

vk::PipelineIndirectDeviceAddressInfoNV
Definition: vulkan_structs.hpp:92126

vk::PipelineInfoKHR
Definition: vulkan_structs.hpp:92237

vk::PipelineLibraryCreateInfoKHR
Definition: vulkan_structs.hpp:33679

vk::PipelinePropertiesIdentifierEXT
Definition: vulkan_structs.hpp:92601

vk::PipelineRasterizationConservativeStateCreateInfoEXT
Definition: vulkan_structs.hpp:92698

vk::PipelineRasterizationDepthClipStateCreateInfoEXT
Definition: vulkan_structs.hpp:92825

vk::PipelineRasterizationLineStateCreateInfoEXT
Definition: vulkan_structs.hpp:92937

vk::PipelineRasterizationProvokingVertexStateCreateInfoEXT
Definition: vulkan_structs.hpp:93071

vk::PipelineRasterizationStateRasterizationOrderAMD
Definition: vulkan_structs.hpp:93173

vk::PipelineRasterizationStateStreamCreateInfoEXT
Definition: vulkan_structs.hpp:93273

vk::PipelineRenderingCreateInfo
Definition: vulkan_structs.hpp:93384

vk::PipelineRepresentativeFragmentTestStateCreateInfoNV
Definition: vulkan_structs.hpp:93555

vk::PipelineRobustnessCreateInfoEXT
Definition: vulkan_structs.hpp:93655

vk::PipelineSampleLocationsStateCreateInfoEXT
Definition: vulkan_structs.hpp:93789

vk::PipelineShaderStageModuleIdentifierCreateInfoEXT
Definition: vulkan_structs.hpp:93901

vk::PipelineShaderStageRequiredSubgroupSizeCreateInfo
Definition: vulkan_structs.hpp:94142

vk::PipelineTessellationDomainOriginStateCreateInfo
Definition: vulkan_structs.hpp:94229

vk::PipelineVertexInputDivisorStateCreateInfoKHR
Definition: vulkan_structs.hpp:94419

vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV
Definition: vulkan_structs.hpp:94556

vk::PipelineViewportDepthClipControlCreateInfoEXT
Definition: vulkan_structs.hpp:94705

vk::PipelineViewportExclusiveScissorStateCreateInfoNV
Definition: vulkan_structs.hpp:94804

vk::PipelineViewportShadingRateImageStateCreateInfoNV
Definition: vulkan_structs.hpp:95040

vk::PipelineViewportSwizzleStateCreateInfoNV
Definition: vulkan_structs.hpp:95293

vk::PipelineViewportWScalingStateCreateInfoNV
Definition: vulkan_structs.hpp:95518

vk::PresentIdKHR
Definition: vulkan_structs.hpp:95767

vk::PresentInfoKHR
Definition: vulkan_structs.hpp:95884

vk::PresentRegionKHR
Definition: vulkan_structs.hpp:96199

vk::PresentRegionsKHR
Definition: vulkan_structs.hpp:96299

vk::PresentTimeGOOGLE
Definition: vulkan_structs.hpp:96420

vk::PresentTimesInfoGOOGLE
Definition: vulkan_structs.hpp:96503

vk::PrivateDataSlotCreateInfo
Definition: vulkan_structs.hpp:96627

vk::ProtectedSubmitInfo
Definition: vulkan_structs.hpp:96726

vk::PushConstantsInfoKHR
Definition: vulkan_structs.hpp:96821

vk::PushDescriptorSetInfoKHR
Definition: vulkan_structs.hpp:97219

vk::PushDescriptorSetWithTemplateInfoKHR
Definition: vulkan_structs.hpp:97386

vk::QueryLowLatencySupportNV
Definition: vulkan_structs.hpp:97517

vk::QueryPoolPerformanceCreateInfoKHR
Definition: vulkan_structs.hpp:97743

vk::QueryPoolPerformanceQueryCreateInfoINTEL
Definition: vulkan_structs.hpp:97881

vk::QueryPoolVideoEncodeFeedbackCreateInfoKHR
Definition: vulkan_structs.hpp:97982

vk::QueueFamilyCheckpointProperties2NV
Definition: vulkan_structs.hpp:98080

vk::QueueFamilyCheckpointPropertiesNV
Definition: vulkan_structs.hpp:98163

vk::QueueFamilyGlobalPriorityPropertiesKHR
Definition: vulkan_structs.hpp:98246

vk::QueueFamilyProperties2
Definition: vulkan_structs.hpp:98455

vk::QueueFamilyQueryResultStatusPropertiesKHR
Definition: vulkan_structs.hpp:98540

vk::QueueFamilyVideoPropertiesKHR
Definition: vulkan_structs.hpp:98623

vk::RayTracingPipelineCreateInfoKHR
Definition: vulkan_structs.hpp:98967

vk::RayTracingPipelineCreateInfoNV
Definition: vulkan_structs.hpp:99388

vk::RayTracingPipelineInterfaceCreateInfoKHR
Definition: vulkan_structs.hpp:98859

vk::RayTracingShaderGroupCreateInfoKHR
Definition: vulkan_structs.hpp:98706

vk::RayTracingShaderGroupCreateInfoNV
Definition: vulkan_structs.hpp:99247

vk::RectLayerKHR
Definition: vulkan_structs.hpp:96105

vk::RefreshCycleDurationGOOGLE
Definition: vulkan_structs.hpp:99615

vk::ReleaseSwapchainImagesInfoEXT
Definition: vulkan_structs.hpp:99682

vk::RenderPassAttachmentBeginInfo
Definition: vulkan_structs.hpp:99820

vk::RenderPassCreateInfo2
Definition: vulkan_structs.hpp:101177

vk::RenderPassCreationControlEXT
Definition: vulkan_structs.hpp:101432

vk::RenderPassCreationFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:101598

vk::RenderPassCreationFeedbackInfoEXT
Definition: vulkan_structs.hpp:101528

vk::RenderPassFragmentDensityMapCreateInfoEXT
Definition: vulkan_structs.hpp:101696

vk::RenderPassInputAttachmentAspectCreateInfo
Definition: vulkan_structs.hpp:101794

vk::RenderPassMultiviewCreateInfo
Definition: vulkan_structs.hpp:101926

vk::RenderPassSampleLocationsBeginInfoEXT
Definition: vulkan_structs.hpp:102211

vk::RenderPassStripeBeginInfoARM
Definition: vulkan_structs.hpp:102480

vk::RenderPassStripeInfoARM
Definition: vulkan_structs.hpp:102384

vk::RenderPassStripeSubmitInfoARM
Definition: vulkan_structs.hpp:102737

vk::RenderPassSubpassFeedbackCreateInfoEXT
Definition: vulkan_structs.hpp:102943

vk::RenderPassSubpassFeedbackInfoEXT
Definition: vulkan_structs.hpp:102865

vk::RenderPassTransformBeginInfoQCOM
Definition: vulkan_structs.hpp:103041

vk::RenderingAreaInfoKHR
Definition: vulkan_structs.hpp:103139

vk::RenderingAttachmentInfo
Definition: vulkan_structs.hpp:103307

vk::RenderingFragmentDensityMapAttachmentInfoEXT
Definition: vulkan_structs.hpp:103460

vk::RenderingFragmentShadingRateAttachmentInfoKHR
Definition: vulkan_structs.hpp:103570

vk::RenderingInfo
Definition: vulkan_structs.hpp:103693

vk::ResolveImageInfo2
Definition: vulkan_structs.hpp:103896

vk::ResultValueType
Definition: vulkan.hpp:6687

vk::ResultValueType::type
T type
Definition: vulkan.hpp:6691

vk::ResultValue
Definition: vulkan.hpp:6595

vk::SRTDataNV
Definition: vulkan_structs.hpp:3014

vk::SampleLocationEXT
Definition: vulkan_structs.hpp:6626

vk::SampleLocationsInfoEXT
Definition: vulkan_structs.hpp:6709

vk::SamplerBlockMatchWindowCreateInfoQCOM
Definition: vulkan_structs.hpp:104073

vk::SamplerBorderColorComponentMappingCreateInfoEXT
Definition: vulkan_structs.hpp:104184

vk::SamplerCaptureDescriptorDataInfoEXT
Definition: vulkan_structs.hpp:104295

vk::SamplerCubicWeightsCreateInfoQCOM
Definition: vulkan_structs.hpp:104658

vk::SamplerCustomBorderColorCreateInfoEXT
Definition: vulkan_structs.hpp:104757

vk::SamplerReductionModeCreateInfo
Definition: vulkan_structs.hpp:104849

vk::SamplerYcbcrConversionCreateInfo
Definition: vulkan_structs.hpp:104949

vk::SamplerYcbcrConversionImageFormatProperties
Definition: vulkan_structs.hpp:105126

vk::SamplerYcbcrConversionInfo
Definition: vulkan_structs.hpp:105211

vk::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM
Definition: vulkan_structs.hpp:105310

vk::SemaphoreGetFdInfoKHR
Definition: vulkan_structs.hpp:105857

vk::SemaphoreSignalInfo
Definition: vulkan_structs.hpp:106193

vk::SemaphoreSubmitInfo
Definition: vulkan_structs.hpp:102606

vk::SemaphoreTypeCreateInfo
Definition: vulkan_structs.hpp:106299

vk::SemaphoreWaitInfo
Definition: vulkan_structs.hpp:106407

vk::SetDescriptorBufferOffsetsInfoEXT
Definition: vulkan_structs.hpp:106577

vk::SetLatencyMarkerInfoNV
Definition: vulkan_structs.hpp:106774

vk::SetStateFlagsIndirectCommandNV
Definition: vulkan_structs.hpp:106880

vk::ShaderCreateInfoEXT
Definition: vulkan_structs.hpp:106955

vk::ShaderModuleIdentifierEXT
Definition: vulkan_structs.hpp:107407

vk::ShaderModuleValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:107496

vk::ShaderResourceUsageAMD
Definition: vulkan_structs.hpp:107594

vk::ShaderStatisticsInfoAMD
Definition: vulkan_structs.hpp:107677

vk::ShadingRatePaletteNV
Definition: vulkan_structs.hpp:94932

vk::SharedPresentSurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:107773

vk::SparseImageFormatProperties2
Definition: vulkan_structs.hpp:107932

vk::SparseImageMemoryRequirements2
Definition: vulkan_structs.hpp:108105

vk::StridedDeviceAddressRegionKHR
Definition: vulkan_structs.hpp:108311

vk::SubmitInfo2
Definition: vulkan_structs.hpp:108633

vk::SubpassBeginInfo
Definition: vulkan_structs.hpp:108852

vk::SubpassDependency2
Definition: vulkan_structs.hpp:101007

vk::SubpassDescription2
Definition: vulkan_structs.hpp:100711

vk::SubpassDescriptionDepthStencilResolve
Definition: vulkan_structs.hpp:108948

vk::SubpassEndInfo
Definition: vulkan_structs.hpp:109074

vk::SubpassFragmentDensityMapOffsetEndInfoQCOM
Definition: vulkan_structs.hpp:109158

vk::SubpassResolvePerformanceQueryEXT
Definition: vulkan_structs.hpp:109287

vk::SubpassSampleLocationsEXT
Definition: vulkan_structs.hpp:102123

vk::SubpassShadingPipelineCreateInfoHUAWEI
Definition: vulkan_structs.hpp:109369

vk::SubresourceHostMemcpySizeEXT
Definition: vulkan_structs.hpp:109455

vk::SubresourceLayout2KHR
Definition: vulkan_structs.hpp:109537

vk::SurfaceCapabilities2EXT
Definition: vulkan_structs.hpp:109621

vk::SurfaceCapabilities2KHR
Definition: vulkan_structs.hpp:109882

vk::SurfaceCapabilitiesKHR
Definition: vulkan_structs.hpp:109763

vk::SurfaceCapabilitiesPresentBarrierNV
Definition: vulkan_structs.hpp:110065

vk::SurfaceFormat2KHR
Definition: vulkan_structs.hpp:110234

vk::SurfaceFormatKHR
Definition: vulkan_structs.hpp:110163

vk::SurfacePresentModeCompatibilityEXT
Definition: vulkan_structs.hpp:110512

vk::SurfacePresentModeEXT
Definition: vulkan_structs.hpp:110636

vk::SurfacePresentScalingCapabilitiesEXT
Definition: vulkan_structs.hpp:110733

vk::SurfaceProtectedCapabilitiesKHR
Definition: vulkan_structs.hpp:110879

vk::SwapchainCounterCreateInfoEXT
Definition: vulkan_structs.hpp:110976

vk::SwapchainCreateInfoKHR
Definition: vulkan_structs.hpp:111074

vk::SwapchainDisplayNativeHdrCreateInfoAMD
Definition: vulkan_structs.hpp:111394

vk::SwapchainLatencyCreateInfoNV
Definition: vulkan_structs.hpp:111492

vk::SwapchainPresentBarrierCreateInfoNV
Definition: vulkan_structs.hpp:111588

vk::SwapchainPresentFenceInfoEXT
Definition: vulkan_structs.hpp:111686

vk::SwapchainPresentModeInfoEXT
Definition: vulkan_structs.hpp:111810

vk::SwapchainPresentModesCreateInfoEXT
Definition: vulkan_structs.hpp:111934

vk::SwapchainPresentScalingCreateInfoEXT
Definition: vulkan_structs.hpp:112059

vk::TextureLODGatherFormatPropertiesAMD
Definition: vulkan_structs.hpp:112182

vk::TilePropertiesQCOM
Definition: vulkan_structs.hpp:112265

vk::TimelineSemaphoreSubmitInfo
Definition: vulkan_structs.hpp:112381

vk::TraceRaysIndirectCommand2KHR
Definition: vulkan_structs.hpp:112547

vk::TraceRaysIndirectCommandKHR
Definition: vulkan_structs.hpp:112786

vk::TransformMatrixKHR
Definition: vulkan_structs.hpp:2439

vk::ValidationCacheCreateInfoEXT
Definition: vulkan_structs.hpp:112885

vk::ValidationFeaturesEXT
Definition: vulkan_structs.hpp:113025

vk::ValidationFlagsEXT
Definition: vulkan_structs.hpp:113194

vk::VertexInputAttributeDescription2EXT
Definition: vulkan_structs.hpp:113319

vk::VertexInputBindingDescription2EXT
Definition: vulkan_structs.hpp:113449

vk::VertexInputBindingDivisorDescriptionKHR
Definition: vulkan_structs.hpp:94331

vk::VideoBeginCodingInfoKHR
Definition: vulkan_structs.hpp:113926

vk::VideoCapabilitiesKHR
Definition: vulkan_structs.hpp:114095

vk::VideoCodingControlInfoKHR
Definition: vulkan_structs.hpp:114226

vk::VideoDecodeCapabilitiesKHR
Definition: vulkan_structs.hpp:114323

vk::VideoDecodeH264CapabilitiesKHR
Definition: vulkan_structs.hpp:114406

vk::VideoDecodeH264DpbSlotInfoKHR
Definition: vulkan_structs.hpp:114501

vk::VideoDecodeH264PictureInfoKHR
Definition: vulkan_structs.hpp:114599

vk::VideoDecodeH264ProfileInfoKHR
Definition: vulkan_structs.hpp:114737

vk::VideoDecodeH264SessionParametersAddInfoKHR
Definition: vulkan_structs.hpp:114857

vk::VideoDecodeH264SessionParametersCreateInfoKHR
Definition: vulkan_structs.hpp:115020

vk::VideoDecodeH265CapabilitiesKHR
Definition: vulkan_structs.hpp:115143

vk::VideoDecodeH265DpbSlotInfoKHR
Definition: vulkan_structs.hpp:115231

vk::VideoDecodeH265PictureInfoKHR
Definition: vulkan_structs.hpp:115329

vk::VideoDecodeH265ProfileInfoKHR
Definition: vulkan_structs.hpp:115471

vk::VideoDecodeH265SessionParametersAddInfoKHR
Definition: vulkan_structs.hpp:115573

vk::VideoDecodeH265SessionParametersCreateInfoKHR
Definition: vulkan_structs.hpp:115769

vk::VideoDecodeInfoKHR
Definition: vulkan_structs.hpp:115902

vk::VideoDecodeUsageInfoKHR
Definition: vulkan_structs.hpp:116107

vk::VideoEncodeCapabilitiesKHR
Definition: vulkan_structs.hpp:116204

vk::VideoEncodeH264CapabilitiesKHR
Definition: vulkan_structs.hpp:116323

vk::VideoEncodeH264DpbSlotInfoKHR
Definition: vulkan_structs.hpp:116506

vk::VideoEncodeH264FrameSizeKHR
Definition: vulkan_structs.hpp:116604

vk::VideoEncodeH264GopRemainingFrameInfoKHR
Definition: vulkan_structs.hpp:116698

vk::VideoEncodeH264NaluSliceInfoKHR
Definition: vulkan_structs.hpp:116829

vk::VideoEncodeH264PictureInfoKHR
Definition: vulkan_structs.hpp:116935

vk::VideoEncodeH264ProfileInfoKHR
Definition: vulkan_structs.hpp:117091

vk::VideoEncodeH264QpKHR
Definition: vulkan_structs.hpp:117193

vk::VideoEncodeH264QualityLevelPropertiesKHR
Definition: vulkan_structs.hpp:117287

vk::VideoEncodeH264RateControlInfoKHR
Definition: vulkan_structs.hpp:117419

vk::VideoEncodeH264RateControlLayerInfoKHR
Definition: vulkan_structs.hpp:117559

vk::VideoEncodeH264SessionCreateInfoKHR
Definition: vulkan_structs.hpp:117710

vk::VideoEncodeH264SessionParametersAddInfoKHR
Definition: vulkan_structs.hpp:117825

vk::VideoEncodeH264SessionParametersCreateInfoKHR
Definition: vulkan_structs.hpp:117988

vk::VideoEncodeH264SessionParametersFeedbackInfoKHR
Definition: vulkan_structs.hpp:118111

vk::VideoEncodeH264SessionParametersGetInfoKHR
Definition: vulkan_structs.hpp:118199

vk::VideoEncodeH265CapabilitiesKHR
Definition: vulkan_structs.hpp:118329

vk::VideoEncodeH265DpbSlotInfoKHR
Definition: vulkan_structs.hpp:118534

vk::VideoEncodeH265FrameSizeKHR
Definition: vulkan_structs.hpp:118632

vk::VideoEncodeH265GopRemainingFrameInfoKHR
Definition: vulkan_structs.hpp:118726

vk::VideoEncodeH265NaluSliceSegmentInfoKHR
Definition: vulkan_structs.hpp:118857

vk::VideoEncodeH265PictureInfoKHR
Definition: vulkan_structs.hpp:118964

vk::VideoEncodeH265ProfileInfoKHR
Definition: vulkan_structs.hpp:119109

vk::VideoEncodeH265QpKHR
Definition: vulkan_structs.hpp:119211

vk::VideoEncodeH265QualityLevelPropertiesKHR
Definition: vulkan_structs.hpp:119305

vk::VideoEncodeH265RateControlInfoKHR
Definition: vulkan_structs.hpp:119431

vk::VideoEncodeH265RateControlLayerInfoKHR
Definition: vulkan_structs.hpp:119571

vk::VideoEncodeH265SessionCreateInfoKHR
Definition: vulkan_structs.hpp:119722

vk::VideoEncodeH265SessionParametersAddInfoKHR
Definition: vulkan_structs.hpp:119837

vk::VideoEncodeH265SessionParametersCreateInfoKHR
Definition: vulkan_structs.hpp:120033

vk::VideoEncodeH265SessionParametersFeedbackInfoKHR
Definition: vulkan_structs.hpp:120166

vk::VideoEncodeH265SessionParametersGetInfoKHR
Definition: vulkan_structs.hpp:120261

vk::VideoEncodeInfoKHR
Definition: vulkan_structs.hpp:120411

vk::VideoEncodeQualityLevelInfoKHR
Definition: vulkan_structs.hpp:120637

vk::VideoEncodeQualityLevelPropertiesKHR
Definition: vulkan_structs.hpp:120733

vk::VideoEncodeRateControlInfoKHR
Definition: vulkan_structs.hpp:120948

vk::VideoEncodeRateControlLayerInfoKHR
Definition: vulkan_structs.hpp:120823

vk::VideoEncodeSessionParametersFeedbackInfoKHR
Definition: vulkan_structs.hpp:121131

vk::VideoEncodeSessionParametersGetInfoKHR
Definition: vulkan_structs.hpp:121214

vk::VideoEncodeUsageInfoKHR
Definition: vulkan_structs.hpp:121312

vk::VideoEndCodingInfoKHR
Definition: vulkan_structs.hpp:121434

vk::VideoFormatPropertiesKHR
Definition: vulkan_structs.hpp:121530

vk::VideoInlineQueryInfoKHR
Definition: vulkan_structs.hpp:121637

vk::VideoPictureResourceInfoKHR
Definition: vulkan_structs.hpp:113686

vk::VideoProfileInfoKHR
Definition: vulkan_structs.hpp:86745

vk::VideoProfileListInfoKHR
Definition: vulkan_structs.hpp:121753

vk::VideoReferenceSlotInfoKHR
Definition: vulkan_structs.hpp:113816

vk::VideoSessionCreateInfoKHR
Definition: vulkan_structs.hpp:121877

vk::VideoSessionMemoryRequirementsKHR
Definition: vulkan_structs.hpp:122070

vk::VideoSessionParametersCreateInfoKHR
Definition: vulkan_structs.hpp:122156

vk::VideoSessionParametersUpdateInfoKHR
Definition: vulkan_structs.hpp:122278

vk::ViewportSwizzleNV
Definition: vulkan_structs.hpp:95187

vk::ViewportWScalingNV
Definition: vulkan_structs.hpp:95435

vk::WriteDescriptorSetAccelerationStructureKHR
Definition: vulkan_structs.hpp:123149

vk::WriteDescriptorSetAccelerationStructureNV
Definition: vulkan_structs.hpp:123280

vk::WriteDescriptorSetInlineUniformBlock
Definition: vulkan_structs.hpp:123411

vk::XYColorEXT
Definition: vulkan_structs.hpp:42334

vk::isVulkanHandleType
Definition: vulkan_handles.hpp:2350

vk::AccelerationStructureGeometryDataKHR
Definition: vulkan_structs.hpp:515

vk::AccelerationStructureMotionInstanceDataNV
Definition: vulkan_structs.hpp:3385

vk::DescriptorDataEXT
Definition: vulkan_structs.hpp:24034

vk::DeviceOrHostAddressConstKHR
Definition: vulkan_structs.hpp:139

vk::DeviceOrHostAddressKHR
Definition: vulkan_structs.hpp:680

vk::PerformanceCounterResultKHR
Definition: vulkan_structs.hpp:55461

vk::PerformanceValueDataINTEL
Definition: vulkan_structs.hpp:55943

vk::PipelineExecutableStatisticValueKHR
Definition: vulkan_structs.hpp:91743

module
module
Definition: vulkan.cppm:11

VkVideoSessionParametersKHR
uint64_t VkVideoSessionParametersKHR
Definition: vulkan_core.h:7946

VkImage
uint64_t VkImage
Definition: vulkan_core.h:100

VkSurfaceKHR
uint64_t VkSurfaceKHR
Definition: vulkan_core.h:7513

VkShaderModule
uint64_t VkShaderModule
Definition: vulkan_core.h:113

VkQueryPool
uint64_t VkQueryPool
Definition: vulkan_core.h:110

VkMicromapEXT
uint64_t VkMicromapEXT
Definition: vulkan_core.h:16913

VkIndirectCommandsLayoutNV
uint64_t VkIndirectCommandsLayoutNV
Definition: vulkan_core.h:15109

VkSampler
uint64_t VkSampler
Definition: vulkan_core.h:119

VkRenderPass
uint64_t VkRenderPass
Definition: vulkan_core.h:117

VkCommandPool
uint64_t VkCommandPool
Definition: vulkan_core.h:123

VkPipelineCache
uint64_t VkPipelineCache
Definition: vulkan_core.h:114

VkEvent
uint64_t VkEvent
Definition: vulkan_core.h:109

VkBuffer
uint64_t VkBuffer
Definition: vulkan_core.h:99

VkCuModuleNVX
uint64_t VkCuModuleNVX
Definition: vulkan_core.h:11781

VkPhysicalDevice
struct VkPhysicalDevice_T * VkPhysicalDevice
Definition: vulkan_core.h:102

VkFramebuffer
uint64_t VkFramebuffer
Definition: vulkan_core.h:122

VkBufferView
uint64_t VkBufferView
Definition: vulkan_core.h:111

VkCudaModuleNV
uint64_t VkCudaModuleNV
Definition: vulkan_core.h:15632

VkQueue
struct VkQueue_T * VkQueue
Definition: vulkan_core.h:104

VkDisplayKHR
uint64_t VkDisplayKHR
Definition: vulkan_core.h:7789

VkDisplayModeKHR
uint64_t VkDisplayModeKHR
Definition: vulkan_core.h:7790

VkInstance
struct VkInstance_T * VkInstance
Definition: vulkan_core.h:101

VkDevice
struct VkDevice_T * VkDevice
Definition: vulkan_core.h:103

VkDeferredOperationKHR
uint64_t VkDeferredOperationKHR
Definition: vulkan_core.h:10293

VkOpticalFlowSessionNV
uint64_t VkOpticalFlowSessionNV
Definition: vulkan_core.h:18087

VkFence
uint64_t VkFence
Definition: vulkan_core.h:107

VkDescriptorSet
uint64_t VkDescriptorSet
Definition: vulkan_core.h:120

PFN_vkVoidFunction
void(* PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2925

VkDescriptorPool
uint64_t VkDescriptorPool
Definition: vulkan_core.h:121

VkAccelerationStructureNV
uint64_t VkAccelerationStructureNV
Definition: vulkan_core.h:13282

VkSwapchainKHR
uint64_t VkSwapchainKHR
Definition: vulkan_core.h:7628

VkPipelineLayout
uint64_t VkPipelineLayout
Definition: vulkan_core.h:115

VkShaderEXT
uint64_t VkShaderEXT
Definition: vulkan_core.h:18276

VkDescriptorUpdateTemplate
uint64_t VkDescriptorUpdateTemplate
Definition: vulkan_core.h:4857

VkDescriptorSetLayout
uint64_t VkDescriptorSetLayout
Definition: vulkan_core.h:118

VkAccelerationStructureKHR
uint64_t VkAccelerationStructureKHR
Definition: vulkan_core.h:15736

VkCudaFunctionNV
uint64_t VkCudaFunctionNV
Definition: vulkan_core.h:15633

VkSamplerYcbcrConversion
uint64_t VkSamplerYcbcrConversion
Definition: vulkan_core.h:4856

VkPipeline
uint64_t VkPipeline
Definition: vulkan_core.h:116

VkDebugUtilsMessengerEXT
uint64_t VkDebugUtilsMessengerEXT
Definition: vulkan_core.h:12652

VkCommandBuffer
struct VkCommandBuffer_T * VkCommandBuffer
Definition: vulkan_core.h:106

VkDebugReportCallbackEXT
uint64_t VkDebugReportCallbackEXT
Definition: vulkan_core.h:11447

VkSemaphore
uint64_t VkSemaphore
Definition: vulkan_core.h:105

VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan_core.h:46

VkCuFunctionNVX
uint64_t VkCuFunctionNVX
Definition: vulkan_core.h:11782

VkPrivateDataSlot
uint64_t VkPrivateDataSlot
Definition: vulkan_core.h:6482

VkPerformanceConfigurationINTEL
uint64_t VkPerformanceConfigurationINTEL
Definition: vulkan_core.h:14063

VkImageView
uint64_t VkImageView
Definition: vulkan_core.h:112

VkDeviceMemory
uint64_t VkDeviceMemory
Definition: vulkan_core.h:108

VkValidationCacheEXT
uint64_t VkValidationCacheEXT
Definition: vulkan_core.h:13099

VkVideoSessionKHR
uint64_t VkVideoSessionKHR
Definition: vulkan_core.h:7945

operator!=
std::enable_if< vk::isVulkanHandleType< T >::value, bool >::type operator!=(const T &v, std::nullptr_t)
Definition: vulkan_handles.hpp:16178

operator==
std::enable_if< vk::isVulkanHandleType< T >::value, bool >::type operator==(const T &v, std::nullptr_t)
Definition: vulkan_handles.hpp:16166

VULKAN_HPP_CONST_OR_CONSTEXPR
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan_hpp_macros.hpp:156

VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
#define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
Definition: vulkan_hpp_macros.hpp:196

VULKAN_HPP_NODISCARD
#define VULKAN_HPP_NODISCARD
Definition: vulkan_hpp_macros.hpp:195

VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
#define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
Definition: vulkan_hpp_macros.hpp:176

VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
#define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
Definition: vulkan_hpp_macros.hpp:266

VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:276

VULKAN_HPP_TYPESAFE_EXPLICIT
#define VULKAN_HPP_TYPESAFE_EXPLICIT
Definition: vulkan_hpp_macros.hpp:137

VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:277

VULKAN_HPP_CONSTEXPR
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan_hpp_macros.hpp:154

VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:171

VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:275